ALMaSS: Goose_Population_Manager Class Reference

The class to handle all goose population related matters. More...

#include <Goose_Population_Manager.h>

Inheritance diagram for Goose_Population_Manager:

Public Member Functions
	Goose_Population_Manager (Landscape *L)
	Goose_Population_Manager Constructor. More...

virtual	~Goose_Population_Manager (void)
	Goose_Population_Manager Destructor. More...

int	GetDayTime ()
	Get the time of day (in minutes). For the goose model, sunrise is defined as m_daytime == 0. Hence this function returns the number of minutes since sunrise. More...

int	GetDaylightLeft ()
	Get the daylight minutes left today. More...

int	GetIsDaylight ()
	Is it daylight hours? Daylight starts at m_daytime == 0. More...

bool	InPinkfootSeason ()
	Are we in the pinkfoot hunting season? More...

bool	InGreylagSeason ()
	Are we in the greylag hunting season? More...

void	CreateObjects (int ob_type, TAnimal pvo, struct_Goose data, int number)
	Method for creating a new individual Goose. More...

int	ForageLocationInUse (int a_polyref)
	Tests if a forage location is currently in use, if so returns the index to it. More...

void	AddGeeseToForageLocationP (GooseSpeciesType a_type, int a_polyref, int a_number)
	Adds a goose or geese to the forage location - uses polygon number as reference. More...

void	AddGeeseToForageLocation (GooseSpeciesType a_type, int a_index, int a_number)
	Adds a goose or geese to the forage location - requires an index. More...

void	RemoveGeeseFromForageLocation (GooseSpeciesType a_type, int a_index, int a_number)
	Removes a goose or geese to the forage location - requires an index. More...

int	NewForageLocation (GooseSpeciesType a_type, int a_number, int a_polyref)
	Creates a new forage location and adds a goose or geese to the forage location. Returns an index to the forage location list. More...

GooseActiveForageLocation *	GetForageLocation (unsigned int a_index)
	Returns a pointer to the forage location indexed by index. More...

double	GetFeedingRate (double a_graindensity, GooseSpecies a_species)
	Get the forage rate based on the grain density. More...

double	GetMaizeFeedingRate (double a_maizedensity, GooseSpecies a_species)
	Get the forage rate when feeding on maize. More...

double	GetForageRateDensity (double a_foragedensity)
	Get the forage intake rate for a forage density. More...

double	GetForageGooseDensity (int a_index)
	Returns the total goose density for a forage location. More...

double	GetForageGrazing (int a_index, int gs)
	Returns the forage density for a forage location and goose type. This is species specific. More...

double	GetGrainDensity (int a_index)
	Returns the forage density for a forage location. More...

double	GetMaizeDensity (int a_index)
	Returns the maize forage density for a forage location. More...

void	RemoveGrainKJ (double a_kJ, int a_index)
	Removes kJ eaten as grains from a forage area. More...

void	RemoveMaizeKJ (double a_kJ, int a_index)
	Removes KJ eaten as maize from a forage area. More...

void	Graze (double a_kJ, int a_index)
	Removes KJ as grams veg biomass from a forage area. More...

void	RemoveMaxForageKj (double a_forage, TTypeOfMaxIntakeSource a_maxintakesource, int m_myForageIndex)
	Removes the forage eaten from the field. More...

int	GetBirdsAtForageLoc (int a_index, GooseSpeciesType a_type)
	Returns the number of birds at a forage location - given by a poly ref. More...

int	BirdsToShootAtPoly (int a_poly)
	Returns the number of birds at a forage location - given by a poly ref. More...

void	BirdsShot (int a_polyref, int a_numbershot, GooseHunter *a_Hunter)
	Passes the message to shoot a number of birds at a forage location. More...

void	BangAtPoly (int a_polyref)
	Passes a 'Bang' message to birds near to the location specified by the polygon reference. More...

Goose_Base *	GetLeader (APoint a_homeloc, GooseSpecies a_species)
	Asks for a pointer to a goose that can be followed. More...

void	FindClosestRoost (int &a_x, int &a_y, unsigned a_type)
	Changes a_x & a_y to the location of the nearest roost of a_type to a_x, a_y. More...

double	GetDistToClosestRoost (int a_x, int a_y, unsigned a_type)
	Returns the distance in to the nearest roost of a_type in meters. More...

double	GetThermalCosts (GooseSpecies a_goose)
	Get daily thermal costs const. More...

int	GetNumberOfForageLocs (void)
	Get the number of forage locations. More...

int	GetForageLocIndex (GooseSpecies a_species, int a_x, int a_y)
	Get a forage location for my species (picked randomly among the active locations) More...

void	RecordIndForageLoc (double a_count, int a_groupsize, GooseSpecies a_species)
	Record a forage location count. More...

void	RecordWeight (double a_weight, GooseSpecies a_species)
	Record the weight. More...

void	RecordHabitatUse (int a_habitatype, GooseSpecies a_species, int a_count)
	Record the habitat use. More...

void	RecordHabitatUseFieldObs (int a_habitatype, GooseSpecies a_species, int a_count)
	Record the habitat use. More...

void	RecordForagingTime (int a_time, GooseSpecies a_species)
	Record the time spent foraging. More...

void	RecordFlightDistance (int a_distance, GooseSpecies a_species)
	Record the flight distance. More...

void	RecordDailyEnergyBudget (int a_deb, GooseSpecies a_species)
	Record the daily energy budget. More...

void	RecordDailyEnergyBalance (int a_balance, GooseSpecies a_species)
	Record the daily energy balance. More...

void	RecordState ()
	Record the state. More...

void	RecordLeaveReason (TTypeOfLeaveReason a_leavereason, GooseSpeciesType a_speciestype)
	Record the reason for leaving. More...

Public Member Functions inherited from Population_Manager
	Population_Manager (Landscape *L)

virtual	~Population_Manager (void)

void	SetNoProbes (int a_pn)

unsigned	GetLiveArraySize (int a_listindex)
	Gets the number of 'live' objects for a list index in the TheArray. More...

void	IncLiveArraySize (int a_listindex)
	Increments the number of 'live' objects for a list index in the TheArray. More...

virtual void	Catastrophe (int)

unsigned int	FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)

char *	SpeciesSpecificReporting (int a_species, int a_time)

char *	ProbeReport (int a_time)

char *	ProbeReportTimed (int a_time)

void	ImpactProbeReport (int a_Time)

bool	BeginningOfMonth ()

void	LOG (const char *fname)

int	SupplyStepSize ()

int	SupplySimW ()

int	SupplySimH ()

virtual void	Run (int NoTSteps)

virtual float	Probe (int ListIndex, probe_data *p_TheProbe)

virtual void	ImpactedProbe ()

int	SupplyListNameLength ()

TAnimal *	SupplyAnimalPtr (int a_index, int a_animal)
	Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...

unsigned	SupplyListIndexSize ()

unsigned	SupplyListSize (unsigned listindex)

bool	CheckXY (int l, int i)
	Debug method to test for out of bounds coordinates. More...

const char *	SupplyListName (int i)

bool	IsLast (unsigned listindex)

int	SupplyState (unsigned listindex, unsigned j)

virtual void	SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)

const char *	SupplyStateNames (int i)

unsigned	SupplyStateNamesLength ()

virtual void	DisplayLocations ()

int	ProbeFileInput (char *p_Filename, int p_ProbeNo)

TAnimal *	FindClosest (int x, int y, unsigned Type)

bool	OpenTheRipleysOutputProbe (string a_NWordFilename)

void	OpenTheAOROutputProbe (string a_AORFilename)

bool	OpenTheMonthlyRipleysOutputProbe ()

bool	OpenTheReallyBigProbe ()

virtual void	TheReallyBigOutputProbe ()

void	CloseTheMonthlyRipleysOutputProbe ()

TTypesOfPopulation	GetPopulationType ()

int	GetSeasonNumber ()
	Get the season number. More...

void	LamdaDeath (int x, int y)

void	LamdaBirth (int x, int y)

void	LamdaBirth (int x, int y, int z)

void	LamdaClear ()

void	LamdaDumpOutput ()

virtual int	SupplyPegPosx (int)

virtual int	SupplyPegPosy (int)

virtual int	SupplyCovPosx (int)

virtual int	SupplyCovPosy (int)

virtual bool	OpenTheFledgelingProbe ()

virtual bool	OpenTheBreedingPairsProbe ()

virtual bool	OpenTheBreedingSuccessProbe ()

virtual void	BreedingPairsOutput (int)

virtual int	TheBreedingFemalesProbe (int)

virtual int	TheFledgelingProbe ()

virtual void	BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)

virtual int	TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)

virtual void	FledgelingProbeOutput (int, int)

virtual void	TheGeneticProbe (unsigned, int, unsigned &)

virtual void	GeneticsResultsOutput (FILE *, unsigned)

Public Attributes
std::vector< GooseActiveForageLocation >	m_GooseForageLocations
	Is a list of active goose forage locations where we have geese. More...

Variate_gen *	m_variate_generator
	Function to be able to draw randomly from predefined distributions. More...

Public Attributes inherited from Population_Manager
int	IndexArrayX [5][10000]

probe_data *	TheProbe [100]

int	SimH

int	SimW

unsigned	SimHH

unsigned	SimWH

char	m_SimulationName [255]

bool	ProbesSet

Landscape *	m_TheLandscape

Protected Member Functions
virtual void	Init (void)
	Called upon initialization of the simulation. Sets up output files. More...

virtual void	DoFirst (void)
	Things to do before anything else at the start of a timestep. More...

virtual void	DoBefore ()
	Things to do before the Step. More...

virtual void	DoAfter ()
	Things to do before the EndStep. More...

virtual void	DoLast ()
	Things to do after the EndStep. More...

virtual void	DoImmigration ()
	Controls immigration to the Danish simulation area. More...

virtual void	DoEmigration ()
	Controls emigration from the Danish simulation area. More...

void	GoosePopulationDescriptionOutput ()
	Produces output to a standard file describing the state of the goose populations. More...

void	GooseFieldForageInfoOutput ()
	Produces output to a standard file describing the energetic state of all individuals of the goose populations. More...

void	GooseEnergyRecordOutput ()
	Produces output to a standard file describing the number of birds foraging at each field and the field conditions. More...

void	GooseWeightStatOutput ()
	Outputs simple stats for the weights in the population. More...

void	GooseIndLocCountOutput ()
	Outputs simple stats for the number of forage locations visited per goose. More...

void	GooseHabitatUseOutput ()
	Outputs simple stats for the goose habitat use. More...

void	GooseHabitatUseFieldObsOutput ()
	Outputs simple stats for the goose habitat use but using rules to mimic field observations. More...

void	ClearIndLocCountStats ()
	Clear simple stats for forage location counts. More...

void	ClearGooseWeightStats ()
	Clear simple stats for the weights in the population. More...

void	ClearGooseHabitatUseStats ()
	Clear simple stats for habitat use. More...

void	ClearGooseHabitatUseFieldObsStats ()
	Clear simple stats for field obs habitat use. More...

void	ClearGooseForagingTimeStats ()
	Clear simple stats for foraging times in the population. More...

void	ClearGooseFlightDistanceStats ()
	Clear simple stats for flight distances in the population. More...

void	ClearGooseDailyEnergyBudgetStats ()
	Clear simple stats for daily energy budget in the population. More...

void	ClearGooseDailyEnergyBalanceStats ()
	Clear simple stats for daily energy balance in the population. More...

void	ClearStateStats ()
	Clear simple stats for the states. More...

void	StateStatOutput ()
	Write simple stats for the states. More...

void	GooseLeaveReasonStatOutput ()
	Outputs simple stats for the reasons for leaving the simulation. More...

void	ClearGooseLeaveReasonStats ()
	Clear simple stats for the reasons for leaving the simulation. More...

void	ObservedOpennessQuery ()
	Writes a file with the openness scores on places where geese have been observed in the field. More...

void	WriteConfig ()
	Writes a file the values of the config variables used. More...

void	GetImmigrationNumbers (GooseSpecies a_goose, bool a_season)
	Get the numbers to immigrate. More...

bool	InHuntingSeason (int a_day, GooseSpecies a_species)
	Are we in the hunting season? More...

void	WriteHeaders (ofstream *a_file, std::vector< std::string > a_headers)
	Handy function for writing headers. More...

virtual void	TheAOROutputProbe ()
	The modified goose version of the standard output for creating AOR statistics. More...

virtual void	TheRipleysOutputProbe (FILE *)
	Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used. More...

virtual void	CloseTheRipleysOutputProbe ()
	Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used. More...

virtual void	CloseTheReallyBigOutputProbe ()
	Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used. More...

void	XYDump ()
	Outputs x y data. More...

std::string	GooseTypeToString (GooseSpeciesType a_gst)
	Translates gst enum to string More...

std::string	GooseToString (GooseSpecies a_gs)
	Translates gs enum to string More...

std::string	IntakeSourceToString (TTypeOfMaxIntakeSource a_intake_source)
	Translates tomis enum to string More...

std::string	LeaveReasonToString (TTypeOfLeaveReason a_leave_reason)
	Translates tolr enum to string More...

Protected Member Functions inherited from Population_Manager
virtual bool	StepFinished ()
	Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...

virtual void	DoAlmostLast ()

void	EmptyTheArray ()
	Removes all objects from the TheArray by deleting them and clearing TheArray. More...

void	SortX (unsigned Type)

void	SortXIndex (unsigned Type)

void	SortY (unsigned Type)

void	SortState (unsigned Type)

void	SortStateR (unsigned Type)

unsigned	PartitionLiveDead (unsigned Type)

void	Shuffle_or_Sort (unsigned Type)

void	Shuffle (unsigned Type)

virtual void	Catastrophe ()

Protected Attributes
int	m_daytime
	Holds the time of day. Note that sunrise is at m_daytime == 0. More...

bool	m_daylight
	Flag for in daylight hours. Sunrise is always at m_daytime == 0. More...

int	m_daylightleft
	Number of daylight minutes left. More...

double	m_thermalcosts [3]
	Temporary storage for daily goose energetic thermal costs constant for each species. More...

std::vector< int >	m_youngdist
	The observed distribution of young for pink feet. More...

int	m_migrationnumbers [3][2]
	Storage for goose numbers. Used when birds are immigrating. More...

bool	m_PinkfootSeason
	Flag to indicate if we are in the pinkfoot hunting season? More...

bool	m_GreylagSeason
	Flag to indicate if we are in the greylag hunting season. More...

std::vector< roostlist >	m_roosts
	The list of roosts More...

HollingsDiscCurveClass *	m_IntakeRateVSGrainDensity_PF
	Speed optimisation to hold all potential forage rates in the range 0-X grain density per m2. More...

HollingsDiscCurveClass *	m_IntakeRateVSMaizeDensity_BN
	Speed optimisation to hold all potential forage rates in the range 0-X maize density per m2. More...

PettiforFeedingTimeCurveClass *	m_ForageRateVSGooseDensity
	Speed optimisation to hold all potential competition reductions in the range 0 - 1 goose/m2. More...

ofstream *	m_GoosePopDataFile
	Pointer to an output file for goose population data. More...

ofstream *	m_GooseEnergeticsDataFile
	Pointer to an output file for goose energetics data. More...

ofstream *	m_GooseHabitatUseFile
	Pointer to an output file for goose habitat use data. More...

ofstream *	m_GooseHabitatUseFieldObsFile
	Pointer to an output file for goose habitat use data, field observation mimic version. More...

ofstream *	m_GooseIndLocCountFile
	Pointer to an output file for goose individual forage location count data. More...

ofstream *	m_GooseWeightStatsFile
	Pointer to an output file for goose weight stats data. More...

ofstream *	m_GooseLeaveReasonStatsFile
	Pointer to an output file for goose leave reason stats data. More...

ofstream *	m_GooseFieldForageDataFile
	Pointer to an output file for goose field forage data. More...

ofstream *	m_GooseGitVersionFile
	Pointer to an output file for almass version. More...

int	m_HabitatUseStats [gs_foobar *tomis_foobar]
	Data for the habitat use. More...

int	m_HabitatUseFieldObsStats [gs_foobar *tomis_foobar]
	Data for the habitat use, field observation mimic version. More...

SimpleStatistics	m_IndividualForageLocationData [gs_foobar]
	Statistics for the number of forage locations visited per goose of the population. More...

SimpleStatistics	m_WeightStats [gs_foobar]
	Statistics for the weights of the population. More...

SimpleStatistics	m_ForagingTimeStats [gs_foobar]
	Statistics for the time spent foraging for the population. More...

SimpleStatistics	m_FlightDistanceStats [gs_foobar]
	Statistics for the flight distances in the population. More...

SimpleStatistics	m_DailyEnergyBudgetStats [gs_foobar]
	Statistics for the daily energy budget in the population. More...

SimpleStatistics	m_DailyEnergyBalanceStats [gs_foobar]
	Statistics for the daily energy balance in the population. More...

ofstream *	m_StateStatsFile
	Pointer to an output file for state stats data. More...

SimpleStatistics	m_StateStats
	Debugging code. Statistics for the number of times a state method is called. More...

SimpleStatistics	m_LeaveReasonStats [gst_foobar][tolr_foobar]
	Statistics for reasons for leaving the simulation. More...

AOR_Probe_Goose *	m_AOR_Pinkfeet
	AOR Probe for pinkfeet. More...

AOR_Probe_Goose *	m_AOR_Barnacles
	AOR Probe for barnacles. More...

AOR_Probe_Goose *	m_AOR_Greylags
	AOR Probe for greylags. More...

ofstream *	m_GooseXYDumpFile
	Pointer to an output file for goose x y data. More...

Protected Attributes inherited from Population_Manager
vector< unsigned >	m_LiveArraySize

int	m_NoProbes

AOR_Probe *	m_AOR_Probe

FILE *	m_GeneticsFile

FILE *	m_AlleleFreqsFile

FILE *	m_EasyPopRes

const char *	StateNames [100]

int	m_catastrophestartyear

int	m_StepSize

vector< TListOfAnimals >	TheArray

unsigned	StateNamesLength

const char *	m_ListNames [32]

unsigned	m_ListNameLength

FILE *	TestFile

FILE *	TestFile2

unsigned	BeforeStepActions [12]

int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...

TTypesOfPopulation	m_population_type

ofstream *	AOROutputPrb

FILE *	RipleysOutputPrb

FILE *	RipleysOutputPrb1

FILE *	RipleysOutputPrb2

FILE *	RipleysOutputPrb3

FILE *	RipleysOutputPrb4

FILE *	RipleysOutputPrb5

FILE *	RipleysOutputPrb6

FILE *	RipleysOutputPrb7

FILE *	RipleysOutputPrb8

FILE *	RipleysOutputPrb9

FILE *	RipleysOutputPrb10

FILE *	RipleysOutputPrb11

FILE *	RipleysOutputPrb12

FILE *	ReallyBigOutputPrb

long int	lamdagrid [2][257][257]

Detailed Description

The class to handle all goose population related matters.

Constructor & Destructor Documentation

◆ Goose_Population_Manager()

Goose_Population_Manager::Goose_Population_Manager ( Landscape * L )

Goose_Population_Manager Constructor.

Set up before step action sorts This determines how we handle the arrays between steps

There is a mandatory file for goose populations that describe the roost locations for each goose type in the landscape - GooseRoosts.txt For each type of goose the x,y locations for roosts are listed

Read in a file with the distribution of the brood sizes as observed from the field. We only have data from Pinkfeet, so this distribution is recycled for the other species

Create curves for food intake rates and forage rates

                                                                : Population_Manager(L)
 {
     g_torun = cfg_goose_ModelExitDay.value();
     // Initialise member variables
     m_thermalcosts[0] = 0.0;
     m_thermalcosts[1] = 0.0;
     m_thermalcosts[2] = 0.0;
     // Set start of day - which is at sunrise. 10 is added to m_daytime in DoFirst. Therfore we start out with -10.
     m_daytime = -10;
     // Load List of Animal Classes
     m_ListNames[0] = "Pinkfoot Family";
     m_ListNames[1] = "Pinkfoot Nonbreeder";
     m_ListNames[2] = "Barnacle Family";
     m_ListNames[3] = "Barnacle Nonbreeder";
     m_ListNames[4] = "Greylag Family";
     m_ListNames[5] = "Greylag Nonbreeder";
     m_ListNameLength = 6;
     m_population_type = TOP_Goose;
     // We need one vector for each life stage
     for (unsigned i=0; i<(10-m_ListNameLength); i++)
     {
         TheArray.pop_back();
     }
     strcpy( m_SimulationName, "Goose Simulation" );
     BeforeStepActions[0]=5; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
     BeforeStepActions[1]=5; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
     BeforeStepActions[2]=5; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
     BeforeStepActions[3]=5; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
     BeforeStepActions[4]=5; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
     ifstream ifile("GooseRoosts.txt");
     if (!ifile.is_open())
     {
         m_TheLandscape->Warn("Goose_Population_Manager::Goose_Population_Manager(Landscape* L) ","GooseRoosts.txt missing");
         exit(1);
     }
     int no_entries;
     ifile >> no_entries;
     roostlist r;
     for (unsigned i = 0; i < gs_foobar; i++) m_roosts.push_back(r);
     for (int i=0; i< no_entries; i++)
     {
         int type;
         APoint ap;
         ifile >> type >> ap.m_x >> ap.m_y;
         m_roosts[type].push_back(ap);
     }
  
     ifstream jfile( "PfYoungDist.txt" );
     if (!jfile.is_open()) {
         m_TheLandscape->Warn( "Goose_Population_Manager::Goose_Population_Manager(Landscape* L) ", "PfYoungDist.txt missing" );
         exit( 1 );
     }
     no_entries;
     jfile >> no_entries;
     for (int i = 0; i< no_entries; i++) {
         int young;
         jfile >> young;
         m_youngdist.push_back( young );
     }
     // We dont start in the hunting season
     m_PinkfootSeason = false;
     m_GreylagSeason = false;
     // We make one goose base just to access its static members
     APoint pt;
     pt.m_x = 0;
     pt.m_y = 0;
     Goose_Base gb(NULL,NULL,1,true, pt);
     gb.SetFlightCost(cfg_goose_flightcost.value());
     gb.Set_mingooseforagerate(0.0, gs_Pinkfoot);
     gb.Set_mingooseforagerate(0.0, gs_Barnacle);
     gb.Set_mingooseforagerate(0.0, gs_Greylag);
     gb.Set_Indivmingooseforagerate( 0.0 );
     gb.Set_GooseMaxAppetiteScaler(cfg_goose_MaxAppetiteScaler.value());
     gb.Set_GooseMaxEnergyReserveProportion( cfg_goose_MaxEnergyReserveProportion.value() );
     gb.Set_GooseKJtoFatConversion( 1.0/(cfg_goose_EnergyContentOfFat.value() + cfg_goose_MetabolicConversionCosts.value()));
     gb.Set_GooseFattoKJConversion(1.0 / (cfg_goose_EnergyContentOfFat.value() - cfg_goose_MetabolicConversionCosts.value()));
     gb.Set_GooseMinForageOpenness( cfg_goose_MinForageOpenness.value() );
     gb.Set_GooseLeavingThreshold( cfg_goose_LeavingThreshold.value() * 5.0); // 5 because we use a 5-day running average
     gb.Set_GooseForageDist(cfg_goose_pf_ForageDist.value(), cfg_goose_bn_ForageDist.value(), cfg_goose_gl_ForageDist.value());
     gb.Set_GooseFieldForageDist(cfg_goose_pf_FieldForageDist.value(), cfg_goose_bn_FieldForageDist.value(), cfg_goose_gl_FieldForageDist.value());
  
     gb.Set_GooseFollowingLikelyhood(cfg_goose_bn_followinglikelyhood.value(), gst_BarnacleFamilyGroup);
     gb.Set_GooseFollowingLikelyhood(cfg_goose_pf_followinglikelyhood.value(), gst_PinkfootFamilyGroup);
     gb.Set_GooseFollowingLikelyhood(cfg_goose_gl_followinglikelyhood.value(), gst_GreylagFamilyGroup);
     // We use the value for families for NB also. Currently not possible to quantify a difference. 
     // At a later stage we might want to explore this more, so we keep the cfg for later.
     gb.Set_GooseFollowingLikelyhood(cfg_goose_bn_followinglikelyhood.value(), gst_BarnacleNonBreeder);
     gb.Set_GooseFollowingLikelyhood(cfg_goose_pf_followinglikelyhood.value(), gst_PinkfootNonBreeder);
     gb.Set_GooseFollowingLikelyhood(cfg_goose_gl_followinglikelyhood.value(), gst_GreylagNonBreeder);
  
     gb.Set_GooseLeavingRoost( true );
     m_ForageRateVSGooseDensity = new PettiforFeedingTimeCurveClass(cfg_Petti1A.value(), cfg_Petti1B.value(), cfg_Petti1C.value(), cfg_Petti1D.value(), cfg_Petti1E.value(), cfg_Petti1F.value(), cfg_Petti1G.value());
     m_IntakeRateVSGrainDensity_PF = new HollingsDiscCurveClass(cfg_H1A.value(), cfg_H1B.value(), cfg_H1C.value(), cfg_H1D.value(), cfg_H1E.value(), cfg_H1F.value());
     m_IntakeRateVSMaizeDensity_BN = new HollingsDiscCurveClass( cfg_H2A.value(), cfg_H2B.value(), cfg_H2C.value(), cfg_H2D.value(), cfg_H2E.value(), cfg_H2F.value() );
     if (cfg_WriteCurve.value()) {
         m_ForageRateVSGooseDensity->WriteDataFile( 10 );
         m_IntakeRateVSGrainDensity_PF->WriteDataFile( 10 );
         m_IntakeRateVSMaizeDensity_BN->WriteDataFile( 10 );
     }
     // Set up a normal distribution which we can then draw from at random
     Mersenne_Twister twister;
     NormalDistDouble LeaveNormal( cfg_goose_RoostLeaveDistMean.value(), cfg_goose_RoostLeaveDistSD.value() );  // mean and std 
     m_variate_generator = new Variate_gen( twister, LeaveNormal );
     Init();
 }

◆ ~Goose_Population_Manager()

Goose_Population_Manager::~Goose_Population_Manager ( void )

virtual

Goose_Population_Manager Destructor.

Close files and delete pointers to them

Delete any memory constructs created by new

 {
     m_GoosePopDataFile->close();
     delete m_GoosePopDataFile;
     m_GooseFieldForageDataFile->close();
     delete m_GooseFieldForageDataFile;
     m_GooseEnergeticsDataFile->close();
     delete m_GooseEnergeticsDataFile;
     m_GooseIndLocCountFile->close();
     delete m_GooseIndLocCountFile;
     m_GooseHabitatUseFile->close();
     delete m_GooseHabitatUseFile;
     m_GooseHabitatUseFieldObsFile->close();
     delete m_GooseHabitatUseFieldObsFile;
     m_GooseWeightStatsFile->close();
     delete m_GooseWeightStatsFile;
     delete m_IntakeRateVSGrainDensity_PF;
     delete m_IntakeRateVSMaizeDensity_BN;
     delete m_ForageRateVSGooseDensity;
     delete m_variate_generator;
     if (cfg_AOROutput_used.value()) {
         delete m_AOR_Pinkfeet;
         delete m_AOR_Greylags;
         delete m_AOR_Barnacles;
     }
     m_GooseXYDumpFile->close();
     delete m_GooseXYDumpFile;
     if (l_map_print_git_version_info.value()) {
         m_GooseGitVersionFile ->close();
         delete m_GooseGitVersionFile;
     }
 }

References cfg_AOROutput_used, l_map_print_git_version_info, m_AOR_Barnacles, m_AOR_Greylags, m_AOR_Pinkfeet, m_ForageRateVSGooseDensity, m_GooseEnergeticsDataFile, m_GooseFieldForageDataFile, m_GooseGitVersionFile, m_GooseHabitatUseFieldObsFile, m_GooseHabitatUseFile, m_GooseIndLocCountFile, m_GoosePopDataFile, m_GooseWeightStatsFile, m_GooseXYDumpFile, m_IntakeRateVSGrainDensity_PF, m_IntakeRateVSMaizeDensity_BN, m_variate_generator, and CfgBool::value().

Member Function Documentation

◆ AddGeeseToForageLocation()

void Goose_Population_Manager::AddGeeseToForageLocation	(	GooseSpeciesType	a_type,
		int	a_index,
		int	a_number
	)

Adds a goose or geese to the forage location - requires an index.

  {
      m_GooseForageLocations[a_index].AddGeese(a_type, a_number);
  }

References m_GooseForageLocations.

Referenced by Goose_Base::st_ChooseForageLocation().

◆ AddGeeseToForageLocationP()

void Goose_Population_Manager::AddGeeseToForageLocationP	(	GooseSpeciesType	a_type,
		int	a_polyref,
		int	a_number
	)

Adds a goose or geese to the forage location - uses polygon number as reference.

f First step is to get the forage location - then add the number of birds of a_type to it.

  {
     int index = ForageLocationInUse( a_polyref );
     if (index == -1 )
     {
         NewForageLocation(a_type,a_number, a_polyref);
     }
     else m_GooseForageLocations[index].AddGeese(a_type, a_number);
  }

References ForageLocationInUse(), m_GooseForageLocations, and NewForageLocation().

◆ BangAtPoly()

void Goose_Population_Manager::BangAtPoly ( int a_polyref )

Passes a 'Bang' message to birds near to the location specified by the polygon reference.

Here we have to find all the geese that are near to this polygon - then tell them they are scared of this location. Unfortunately there is no easy way to do this except trawl through all geese and test the distance they are from the bang at the moment this method is called. We assume the bang occurs at the centroid since we do not have a particular location for this within the polygon. Centroid distance to the location of each bird is checked and if under the maximum threat distance then we tell the bird they are scared. An alternative approach would be to link the size of scare to the distance. This is provided as an alternative assuming __LINKGOOSESCARETODISTANCE is defined.

 {
     int polyX = m_TheLandscape->SupplyCentroidX(a_polyref);
     int polyY = m_TheLandscape->SupplyCentroidY(a_polyref);
     int maxscaredist = cfg_goose_MaxScareDistance.value();
     for (unsigned i=0; i<(m_ListNameLength); i++)
     {
         unsigned sz = (unsigned) TheArray[i].size();
         for (unsigned j=0; j<sz; j++)
         {
             APoint ap = TheArray[i][j]->SupplyPoint();
             int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( polyX, polyY, ap.m_x, ap.m_y );
             if (dist < maxscaredist)
             {
                 Goose_Base* gb = dynamic_cast<Goose_Base*>(TheArray[i][j]);
 #ifdef __LINKGOOSESCARETODISTANCE
  
                 gb->On_Bang(a_polyref, 1.0-(double) (dist/maxscaredist));
 #else
                 gb->On_Bang(a_polyref);
 #endif
             }
         }
     }
 }

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), cfg_goose_MaxScareDistance, g_AlmassMathFuncs, Population_Manager::m_ListNameLength, Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, Goose_Base::On_Bang(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Population_Manager::TheArray, and CfgInt::value().

Referenced by GooseHunter::st_OutHunting().

◆ BirdsShot()

void Goose_Population_Manager::BirdsShot	(	int	a_polyref,
		int	a_numbershot,
		GooseHunter *	a_Hunter
	)

Passes the message to shoot a number of birds at a forage location.

First step is to get the forage location - the we pick a_numbershot birds to kill. This is a bit problematic since we know the type of birds but not exactly which ones are here. To speed things up as much as possible we first determine which birds will be shot by picking randomly from the birds here. Next we need to make some 'BANG's and scare the birds away from this location and nearby locations. Note that barnacle geese cannot be shot and are excluded by the loop below.

Todo:: Add input parameter to docu

  {
      int index = ForageLocationInUse(a_polyref);
      if (index == -1)
      {
          g_msg->Warn("Goose_Population_Manager::BirdsShot - No birds at this location to shoot. Tried to kill ", a_numbershot);
          exit(0);
      }
      int birds = (int)m_GooseForageLocations[index].GetHuntables(); // This is the number of geese not number of objects!
      if (birds < 1) return; // Other hunters have shot all the birds already
      GooseSpeciesType gst = gst_foobar;
      int found = 0;
      int counter = 0;
      while (a_numbershot > 0)
      {
          counter++;
          if (counter > 25)
          {
              int pffg = m_GooseForageLocations[index].GetBirds(gst_PinkfootFamilyGroup);
              int pfnb = m_GooseForageLocations[index].GetBirds(gst_PinkfootNonBreeder);
              int glfg = m_GooseForageLocations[index].GetBirds(gst_GreylagFamilyGroup);
              int glnb = m_GooseForageLocations[index].GetBirds(gst_GreylagNonBreeder);
              //cout << "Goose_Population_Manager::BirdsShot() Been shooting like crazy all morning - something is not quite right here...";
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - where are those damn birds?. Tried to kill ", a_numbershot);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - there where supposed to this many of them:", birds);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - consisting of pinkfoot familygroups:", pffg);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - consisting of pinkfoot nonbreeders:", pfnb);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - consisting of greylag familygroups:", glfg);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - consisting of greylag nonbreeders:", glnb);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - Today is day in year:", g_land->SupplyDayInYear());
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - in year:", g_land->SupplyYear());
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - Pinkfoot season?", m_PinkfootSeason);
              g_msg->Warn("Goose_Population_Manager::BirdsShot() - in while() - Greylag season?", m_GreylagSeason);
              exit(0);
          }
          found = 0;
          int deadbird = (int)(g_rand_uni() * birds);
          {
              found = m_GooseForageLocations[index].GetBirds(gst_PinkfootFamilyGroup);
              if (found > deadbird && InPinkfootSeason()) gst = gst_PinkfootFamilyGroup;
              else {
                  deadbird -= found;
                  found = m_GooseForageLocations[index].GetBirds(gst_PinkfootNonBreeder);
                  if (found > deadbird && InPinkfootSeason()) gst = gst_PinkfootNonBreeder;
                  else {
                      deadbird -= found;
                      found = m_GooseForageLocations[index].GetBirds(gst_GreylagNonBreeder);
                      if (found > deadbird && InGreylagSeason()) gst = gst_GreylagNonBreeder;
                      else {
                          deadbird -= found;
                          found = m_GooseForageLocations[index].GetBirds(gst_GreylagFamilyGroup);
                          if (found > deadbird && InGreylagSeason()) gst = gst_GreylagFamilyGroup;
                      }
                  }
              }
          }
          // gst has the enum value identifying the type of shot bird.
          int sz = int(GetLiveArraySize(gst));
          for (int i = 0; i < sz; i++)
          {
              if (TheArray[gst][i]->SupplyPolygonRef() == a_polyref)
              {
                  if (TheArray[gst][i]->GetCurrentStateNo() != -1)
                  {
                      // Kill the bird
                      TheArray[gst][i]->KillThis();
                      // Tell the hunter
                      a_hunter->OnShotABird(gst, a_polyref);
                      a_numbershot--;
                      break;
                  }
              }
          }
      }
 }

References ForageLocationInUse(), g_land, g_msg, g_rand_uni, Population_Manager::GetLiveArraySize(), gst_foobar, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, InGreylagSeason(), InPinkfootSeason(), m_GooseForageLocations, m_GreylagSeason, m_PinkfootSeason, GooseHunter::OnShotABird(), Landscape::SupplyDayInYear(), Landscape::SupplyYear(), Population_Manager::TheArray, and MapErrorMsg::Warn().

Referenced by GooseHunter::OnShoot(), and GooseHunter::st_OutHunting().

◆ BirdsToShootAtPoly()

int Goose_Population_Manager::BirdsToShootAtPoly ( int a_poly )

Returns the number of birds at a forage location - given by a poly ref.

Assumes that a_protectedpct is initialised to 0.0 on entry. First step is to get the forage location - the find out how many birds are there.

      {
          int index = ForageLocationInUse(a_polyref);
          if (index == -1) return 0;
          // There are birds here - so how many and what type?
          int geese = 0;
          if (InPinkfootSeason())
          {
              geese += m_GooseForageLocations[index].GetBirds(gst_PinkfootFamilyGroup) + m_GooseForageLocations[index].GetBirds(gst_PinkfootNonBreeder);
          }
          if (InGreylagSeason())
          {
              geese += m_GooseForageLocations[index].GetBirds(gst_GreylagFamilyGroup) + m_GooseForageLocations[index].GetBirds(gst_GreylagNonBreeder);
          }
  
          //int protectedgeese = m_GooseForageLocations[index].GetBirds(gst_BarnacleFamilyGroup) + m_GooseForageLocations[index].GetBirds(gst_BarnacleNonBreeder);
          //int birds = geese+protectedgeese;
          //if (protectedgeese> 0) a_protectedpct = protectedgeese / (double)(birds); // else a_protectedpct = 0.0; This is not necessary since a_protectedpct should be 0.0 on entry
          if (geese < 0) {
              g_msg->Warn("Goose_Population_Manager::BirdsToShootAtPoly 0 or less then 0 geese to shoot.", geese);
              exit(0);
          }
          return geese;
      }

References ForageLocationInUse(), g_msg, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, InGreylagSeason(), InPinkfootSeason(), m_GooseForageLocations, and MapErrorMsg::Warn().

Referenced by GooseHunter::OnShoot(), and GooseHunter::st_OutHunting().

◆ ClearGooseDailyEnergyBalanceStats()

void Goose_Population_Manager::ClearGooseDailyEnergyBalanceStats ( )

protected

Clear simple stats for daily energy balance in the population.

 {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_DailyEnergyBalanceStats[(GooseSpecies)i].ClearData();
     }
 }

References m_DailyEnergyBalanceStats.

Referenced by DoLast().

◆ ClearGooseDailyEnergyBudgetStats()

void Goose_Population_Manager::ClearGooseDailyEnergyBudgetStats ( )

protected

Clear simple stats for daily energy budget in the population.

 {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_DailyEnergyBudgetStats[(GooseSpecies)i].ClearData();
     }
 }

References m_DailyEnergyBudgetStats.

Referenced by DoLast().

◆ ClearGooseFlightDistanceStats()

void Goose_Population_Manager::ClearGooseFlightDistanceStats ( )

protected

Clear simple stats for flight distances in the population.

 {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_FlightDistanceStats[(GooseSpecies)i].ClearData();
     }
 }

References m_FlightDistanceStats.

Referenced by DoLast().

◆ ClearGooseForagingTimeStats()

void Goose_Population_Manager::ClearGooseForagingTimeStats ( )

protected

Clear simple stats for foraging times in the population.

 {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_ForagingTimeStats[(GooseSpecies)i].ClearData();
     }
 }

References m_ForagingTimeStats.

Referenced by DoLast().

◆ ClearGooseHabitatUseFieldObsStats()

void Goose_Population_Manager::ClearGooseHabitatUseFieldObsStats ( )

protected

Clear simple stats for field obs habitat use.

                                                                  {
     for (unsigned i = 0; i < gs_foobar*tomis_foobar; i++)
     {
         m_HabitatUseFieldObsStats[i] = 0;
     }
 }

References m_HabitatUseFieldObsStats, and tomis_foobar.

Referenced by GooseHabitatUseFieldObsOutput(), and Init().

◆ ClearGooseHabitatUseStats()

void Goose_Population_Manager::ClearGooseHabitatUseStats ( )

protected

Clear simple stats for habitat use.

                                                          {
     for (unsigned i = 0; i < gs_foobar*tomis_foobar; i++)
     {
         m_HabitatUseStats[i] = 0;
     }
 }

References m_HabitatUseStats, and tomis_foobar.

Referenced by GooseHabitatUseOutput(), and Init().

◆ ClearGooseLeaveReasonStats()

void Goose_Population_Manager::ClearGooseLeaveReasonStats ( )

protected

Clear simple stats for the reasons for leaving the simulation.

                                                           {
     for (unsigned i = 0; i < gst_foobar; i++)
     {
         for (unsigned j = 0; j < tolr_foobar; j++)
         {
             m_LeaveReasonStats[(GooseSpeciesType)i][(TTypeOfLeaveReason)j].ClearData();
         }
     }
 }

References SimpleStatistics::ClearData(), gst_foobar, m_LeaveReasonStats, and tolr_foobar.

Referenced by DoLast().

◆ ClearGooseWeightStats()

void Goose_Population_Manager::ClearGooseWeightStats ( )

protected

Clear simple stats for the weights in the population.

                                                      {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_WeightStats[(GooseSpecies)i].ClearData();
     }
 }

References m_WeightStats.

Referenced by DoLast().

◆ ClearIndLocCountStats()

void Goose_Population_Manager::ClearIndLocCountStats ( )

protected

Clear simple stats for forage location counts.

                                                      {
     for (unsigned i = 0; i < gs_foobar; i++)
     {
         m_IndividualForageLocationData[(GooseSpecies)i].ClearData();
     }
 }

References m_IndividualForageLocationData.

Referenced by DoLast().

◆ ClearStateStats()

void Goose_Population_Manager::ClearStateStats ( )

protected

Clear simple stats for the states.

                                                {
         m_StateStats.ClearData();
 }

References SimpleStatistics::ClearData(), and m_StateStats.

Referenced by DoLast().

◆ CloseTheReallyBigOutputProbe()

virtual void Goose_Population_Manager::CloseTheReallyBigOutputProbe ( )

inlineprotectedvirtual

Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used.

Reimplemented from Population_Manager.

832 { ; }

◆ CloseTheRipleysOutputProbe()

virtual void Goose_Population_Manager::CloseTheRipleysOutputProbe ( )

inlineprotectedvirtual

Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used.

Reimplemented from Population_Manager.

830 { ; }

◆ CreateObjects()

void Goose_Population_Manager::CreateObjects	(	int	ob_type,
		TAnimal *	pvo,
		struct_Goose *	data,
		int	number
	)

Method for creating a new individual Goose.

 {
     for (int i = 0; i<a_number; i++)
     {
         switch (a_ob_type)
         {
         case gst_PinkfootFamilyGroup:
             Goose_Pinkfoot_FamilyGroup* new_PFFamilyGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_PFFamilyGoose = dynamic_cast<Goose_Pinkfoot_FamilyGroup*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_PFFamilyGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
             }
             else {
                 new_PFFamilyGoose = new Goose_Pinkfoot_FamilyGroup(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_PFFamilyGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         case gst_PinkfootNonBreeder:
             Goose_Pinkfoot_NonBreeder* new_PFNonbreederGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_PFNonbreederGoose = dynamic_cast<Goose_Pinkfoot_NonBreeder*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_PFNonbreederGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
             }
             else {
                 new_PFNonbreederGoose = new Goose_Pinkfoot_NonBreeder(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_PFNonbreederGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         case gst_BarnacleFamilyGroup:
             Goose_Barnacle_FamilyGroup* new_BFamilyGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_BFamilyGoose = dynamic_cast<Goose_Barnacle_FamilyGroup*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_BFamilyGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
             }
             else {
                 new_BFamilyGoose = new Goose_Barnacle_FamilyGroup(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_BFamilyGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         case gst_BarnacleNonBreeder:
             Goose_Barnacle_NonBreeder* new_BNonbreederGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_BNonbreederGoose = dynamic_cast<Goose_Barnacle_NonBreeder*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_BNonbreederGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
             }
             else {
                 new_BNonbreederGoose = new Goose_Barnacle_NonBreeder(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_BNonbreederGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         case gst_GreylagNonBreeder:
             Goose_Greylag_NonBreeder* new_GNonbreederGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_GNonbreederGoose = dynamic_cast<Goose_Greylag_NonBreeder*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_GNonbreederGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
             }
             else {
                 new_GNonbreederGoose = new Goose_Greylag_NonBreeder(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_GNonbreederGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         case gst_GreylagFamilyGroup:
             Goose_Greylag_FamilyGroup* new_GFamilyGoose;
             if (unsigned(TheArray[a_ob_type].size())>GetLiveArraySize(a_ob_type)) {
                 // We need to reuse an object
                 new_GFamilyGoose = dynamic_cast<Goose_Greylag_FamilyGroup*>(TheArray[a_ob_type][GetLiveArraySize(a_ob_type)]);
                 new_GFamilyGoose->ReInit(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 IncLiveArraySize(a_ob_type);
                 }
             else {
                 new_GFamilyGoose = new Goose_Greylag_FamilyGroup(a_data->m_L, a_data->m_GPM, a_data->m_weight, a_data->m_sex, a_data->m_grpsize, a_data->m_roost);
                 TheArray[a_ob_type].push_back(new_GFamilyGoose);
                 IncLiveArraySize(a_ob_type);
             }
             break;
         default:
             char ob[255];
             sprintf(ob, "%d", (int)a_ob_type);
             m_TheLandscape->Warn("Goose_Population_Manager::CreateObjects() unknown object type - ", ob);
             exit(1);
             break;
         }
     }
 }

References Population_Manager::GetLiveArraySize(), gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, Population_Manager::IncLiveArraySize(), struct_Goose::m_GPM, struct_Goose::m_grpsize, struct_Goose::m_L, struct_Goose::m_roost, struct_Goose::m_sex, Population_Manager::m_TheLandscape, struct_Goose::m_weight, Goose_Barnacle_NonBreeder::ReInit(), Goose_Greylag_NonBreeder::ReInit(), Goose_Pinkfoot_NonBreeder::ReInit(), Goose_Barnacle_FamilyGroup::ReInit(), Goose_Greylag_FamilyGroup::ReInit(), Goose_Pinkfoot_FamilyGroup::ReInit(), Population_Manager::TheArray, and Landscape::Warn().

Referenced by DoImmigration().

◆ DoAfter()

virtual void Goose_Population_Manager::DoAfter ( )

inlineprotectedvirtual

Things to do before the EndStep.

Reimplemented from Population_Manager.

724 { ; }

◆ DoBefore()

virtual void Goose_Population_Manager::DoBefore ( void )

inlineprotectedvirtual

Things to do before the Step.

Reimplemented from Population_Manager.

720 { ; }

◆ DoEmigration()

void Goose_Population_Manager::DoEmigration ( )

protectedvirtual

Controls emigration from the Danish simulation area.

 {
     double emigrationchance;
     // Get the date as day in year
     int today = m_TheLandscape->SupplyDayInYear();
     // Pink foot emigration?
     if ((today >= cfg_goose_pf_leavingdatestart.value()) && (today <= cfg_goose_pf_leavingdateend.value()))
     {
         // Should do some emigration. The chance of this is determined by the date. This is a linearly scaling probability
         // equal to 1/(1+lastdate-today)
         emigrationchance = 1.0 / (1 + cfg_goose_pf_leavingdateend.value() - today);
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_PinkfootFamilyGroup));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_PinkfootNonBreeder));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootNonBreeder][j])->On_Emigrate();
         }
     }
     // Pinkfoot fall migration?
     if (cfg_goose_pf_fallmigrate.value() && (today >= cfg_goose_pf_fallmigdatestart.value()) && (today <= cfg_goose_pf_fallmigdateend.value())) {
         emigrationchance = cfg_goose_pf_fallmig_probability.value();
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_PinkfootFamilyGroup));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_PinkfootNonBreeder));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootNonBreeder][j])->On_Emigrate();
         }
     }
     // Barnacle emigration?
     if ((today >= cfg_goose_bn_leavingdatestart.value()) && (today <= cfg_goose_bn_leavingdateend.value()))
     {
         // Should do some emigration. The chance of this is determined by the date. This is a linearly scaling probability
         // equal to 1/(1+lastdate-today)
         emigrationchance = 1.0 / (1 + cfg_goose_bn_leavingdateend.value() - today);
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_BarnacleFamilyGroup));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_BarnacleFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_BarnacleNonBreeder));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_BarnacleNonBreeder][j])->On_Emigrate();
         }
     }
     // Barnacle fall migration?
     if (cfg_goose_bn_fallmigrate.value() && (today >= cfg_goose_bn_fallmigdatestart.value()) && (today <= cfg_goose_bn_fallmigdateend.value())) {
         emigrationchance = cfg_goose_bn_fallmig_probability.value();
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_BarnacleFamilyGroup));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_BarnacleFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_BarnacleNonBreeder));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_BarnacleNonBreeder][j])->On_Emigrate();
         }
     }
     // Greylag emigration?
     if ((today >= cfg_goose_gl_leavingdatestart.value()) && (today <= cfg_goose_gl_leavingdateend.value()))
     {
         // Should do some emigration. The chance of this is determined by the date. This is a linearly scaling probability
         // equal to 1/(1+lastdate-today)
         emigrationchance = 1.0 / (1 + cfg_goose_gl_leavingdateend.value() - today);
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_GreylagFamilyGroup));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_GreylagFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_GreylagNonBreeder));
         for (int j = 0; j<sz; j++)
         {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_GreylagNonBreeder][j])->On_Emigrate();
         }
     }
     // Greylag fall migration?
     if (cfg_goose_gl_fallmigrate.value() && (today >= cfg_goose_gl_fallmigdatestart.value()) && (today <= cfg_goose_gl_fallmigdateend.value())) {
         emigrationchance = cfg_goose_gl_fallmig_probability.value();
         // Now we loop through all geese and set the behaviour to emigrate
         int sz = int(GetLiveArraySize(gst_GreylagFamilyGroup));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_GreylagFamilyGroup][j])->On_Emigrate();
         }
         sz = int(GetLiveArraySize(gst_GreylagNonBreeder));
         for (int j = 0; j<sz; j++) {
             if (g_rand_uni() <= emigrationchance) dynamic_cast<Goose_Base*>(TheArray[gst_GreylagNonBreeder][j])->On_Emigrate();
         }
     }
 }

References cfg_goose_bn_fallmig_probability, cfg_goose_bn_fallmigdateend, cfg_goose_bn_fallmigdatestart, cfg_goose_bn_fallmigrate, cfg_goose_bn_leavingdateend, cfg_goose_bn_leavingdatestart, cfg_goose_gl_fallmig_probability, cfg_goose_gl_fallmigdateend, cfg_goose_gl_fallmigdatestart, cfg_goose_gl_fallmigrate, cfg_goose_gl_leavingdateend, cfg_goose_gl_leavingdatestart, cfg_goose_pf_fallmig_probability, cfg_goose_pf_fallmigdateend, cfg_goose_pf_fallmigdatestart, cfg_goose_pf_fallmigrate, cfg_goose_pf_leavingdateend, cfg_goose_pf_leavingdatestart, g_rand_uni, Population_Manager::GetLiveArraySize(), gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, Population_Manager::m_TheLandscape, Landscape::SupplyDayInYear(), Population_Manager::TheArray, CfgInt::value(), CfgFloat::value(), and CfgBool::value().

Referenced by DoFirst().

◆ DoFirst()

void Goose_Population_Manager::DoFirst ( void )

protectedvirtual

Things to do before anything else at the start of a timestep.

The Goose_Population_Manager DoFirst has three main functions. The first is to control the variables related to the goose timestep of 10 minutes. Here we assume the daylight hours start at time 0 and go on until the end of the daylength at any given date.
Then, if we are at start of day, then max goose numbers are relayed to the field elements.
Next checks the date and determines if we need to either migrate out of the area or into the area. If so calls the appropriate immigration or emigration code. Otherwise if we are in normal Danish simulation mode then at the start of each day the list of active forage locations is emptied ready to be refilled as the geese start foraging and some global energetic constants are calculated (thermal regulation costs).

Reimplemented from Population_Manager.

 {
     int dlt = m_TheLandscape->SupplyDaylength();
     m_daytime = ( m_daytime + 10 ) % 1440; // We have 10 minutes timesteps. This resets m_daytime to 0 when it hits 1440.
     if (m_daytime < dlt ) m_daylight = true; else m_daylight = false;
     m_daylightleft = dlt - m_daytime;
     /*
     * Next checks the date and determines if we need to either migrate out of the area or into the area. If so calls the appropriate immigration or emigration code.
     * Otherwise if we are in normal Danish simulation mode then at the start of each day the list of active forage locations is emptied ready to be refilled
     * as the geese start foraging.
     */
     if (m_daytime == 0)
     {
         DoImmigration();
         DoEmigration();
         m_GooseForageLocations.clear();
         // Calculate energetic constants for each species
         double temp = m_TheLandscape->SupplyTemp();
         if (temp < cfg_goose_pf_Thermalconstant.value())
         {
             double dt = cfg_goose_pf_Thermalconstant.value() - temp;
             m_thermalcosts[gs_Pinkfoot] = cfg_goose_Thermalconstantb.value() * dt;
         }
         if (temp < cfg_goose_bn_Thermalconstant.value())
         {
             double dt = cfg_goose_bn_Thermalconstant.value() - temp;
             m_thermalcosts[ gs_Barnacle ] = cfg_goose_Thermalconstantb.value() * dt;
         }
         if (temp < cfg_goose_gl_Thermalconstant.value())
         {
             double dt = cfg_goose_gl_Thermalconstant.value() - temp;
             m_thermalcosts[ gs_Greylag ] = cfg_goose_Thermalconstantb.value() * dt;
         }
     }
     /*
     * Then we check if we are in the hunting season of any of the legal quarry species
     */
     int today = m_TheLandscape->SupplyDayInYear();
     if (InHuntingSeason(today, gs_Pinkfoot))
     {
         m_PinkfootSeason = true;
     }
     else m_PinkfootSeason = false;
     if (InHuntingSeason(today, gs_Greylag))
     {
         m_GreylagSeason = true;
     }
     else m_GreylagSeason = false;
     /*
     * By March first we reset all grain and maize resources to make sure we don't get 
     * problems in the following season
     */
     if (today == cfg_goose_grain_and_maize_reset_day.value()) {
         m_TheLandscape->ResetGrainAndMaize();
     }
 }

References cfg_goose_bn_Thermalconstant, cfg_goose_gl_Thermalconstant, cfg_goose_grain_and_maize_reset_day, cfg_goose_pf_Thermalconstant, cfg_goose_Thermalconstantb, DoEmigration(), DoImmigration(), InHuntingSeason(), m_daylight, m_daylightleft, m_daytime, m_GooseForageLocations, m_GreylagSeason, m_PinkfootSeason, Population_Manager::m_TheLandscape, m_thermalcosts, Landscape::ResetGrainAndMaize(), Landscape::SupplyDayInYear(), Landscape::SupplyDaylength(), Landscape::SupplyTemp(), CfgInt::value(), and CfgFloat::value().

◆ DoImmigration()

void Goose_Population_Manager::DoImmigration ( )

protectedvirtual

Controls immigration to the Danish simulation area.

Here we need to determine the inputs in terms of birds to the Danish simulation area and create all the necessary objects and object relationships. This is a tiny bit tricky since it is important that all birds start the simulation with a sensible and complete characteristics.

The first step is to determine whether there are birds of each type to immigrate today, and if so how many. We have the numbers to immigrate and the range of days over which this happens. For sake of simplicity and because we don't have other information we will assume an even distribution of birds over this period.

Pinkfoot spring migration

Barnacle spring migration

Greylag spring migration

 {
     for (int i = 0; i < gs_foobar; ++i)
     {
         m_migrationnumbers[i][0] = 0;
         m_migrationnumbers[i][1] = 0;
     }
  
     // Get the date as day in year
     int today = m_TheLandscape->SupplyDayInYear();
     // Pink foot immigration?
     if ((today >= cfg_goose_pf_arrivedatestart.value()) && (today <= cfg_goose_pf_arrivedateend.value()))
     {
         // there are some birds to come in today
         GetImmigrationNumbers(gs_Pinkfoot, true);  // true is fall immigration
     }
     if (cfg_goose_pf_springmigrate.value()) {
         if (cfg_goose_pf_leavingdateend.value() > today) {
             if ((today >= cfg_goose_pf_springmigdatestart.value()) && (today <= cfg_goose_pf_springmigdateend.value()) && m_SeasonNumber > 0) {
                 // there are some birds to come in today
                 GetImmigrationNumbers(gs_Pinkfoot, false);  // false is spring immigration
             }
         }
     }
     // Barnacle immigration?
     if ((today >= cfg_goose_bn_arrivedatestart.value()) && (today <= cfg_goose_bn_arrivedateend.value()))
     {
         // there are some birds to come in today
         GetImmigrationNumbers(gs_Barnacle, true);
     }
     if (cfg_goose_bn_springmigrate.value()) {
         if (cfg_goose_bn_leavingdateend.value() > today) {
             if ((today >= cfg_goose_bn_springmigdatestart.value()) && (today <= cfg_goose_bn_springmigdateend.value()) && m_SeasonNumber > 0) {
                 // there are some birds to come in today
                 GetImmigrationNumbers(gs_Barnacle, false);
             }
         }
     }
     // Greylag immigration?
     if ((today >= cfg_goose_gl_arrivedatestart.value()) && (today <= cfg_goose_gl_arrivedateend.value()))
     {
         // there are some birds to come in today
         GetImmigrationNumbers(gs_Greylag, true);
     }
     if (cfg_goose_gl_springmigrate.value()) {
         if (cfg_goose_gl_leavingdateend.value() > today) {
             if ((today >= cfg_goose_gl_springmigdatestart.value()) && (today <= cfg_goose_gl_springmigdateend.value()) && m_SeasonNumber > 0) {
                 // there are some birds to come in today
                 GetImmigrationNumbers(gs_Greylag, false);
             }
         }
     }
  
     struct_Goose* gs;
     gs = new struct_Goose;
     gs->m_GPM = this;
     gs->m_L = m_TheLandscape;
     
     int youngno = (int) m_youngdist.size(); // The length of the vector with brood sizes
  
     // Create the pinkfooted families
     for (int i=0; i<m_migrationnumbers[gs_Pinkfoot][0]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Pinkfoot].size());
         gs->m_roost = m_roosts[gs_Pinkfoot][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         gs->m_sex = true;
         gs->m_weight = cfg_goose_pf_baseweight.value();
         gs->m_family = true;
         gs->m_grpsize = 2 + m_youngdist[ random(youngno) ];
         CreateObjects(gst_PinkfootFamilyGroup,NULL,gs,1);
     }
     // Create the pink footed non-breeders
     for (int i = 0; i<m_migrationnumbers[gs_Pinkfoot][1]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Pinkfoot].size());
         gs->m_roost = m_roosts[gs_Pinkfoot][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         if (g_rand_uni() < cfg_goose_pf_sexratio.value()) gs->m_sex = true; else gs->m_sex = false; // true = male, false = female
         gs->m_weight = cfg_goose_pf_baseweight.value();
         gs->m_family = false;
         CreateObjects(gst_PinkfootNonBreeder,NULL,gs,1);
     }
     // Create the barnacle families
     for (int i = 0; i<m_migrationnumbers[gs_Barnacle][0]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Barnacle].size());
         gs->m_roost = m_roosts[gs_Barnacle][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         gs->m_sex = true;
         gs->m_weight = cfg_goose_bn_baseweight.value();
         gs->m_family = true;
         gs->m_grpsize = 2 + m_youngdist[ random( youngno) ];  // Values for Pinkfeet in lack of better data
         CreateObjects(gst_BarnacleFamilyGroup, NULL, gs, 1);
     }
     // Create the barnacle non-breeders
     for (int i = 0; i<m_migrationnumbers[gs_Barnacle][1]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Barnacle].size());
         gs->m_roost = m_roosts[gs_Barnacle][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         if (g_rand_uni() < cfg_goose_bn_sexratio.value()) gs->m_sex = true; else gs->m_sex = false; // true = male, false = female
         gs->m_weight = cfg_goose_bn_baseweight.value();
         gs->m_family = false;
         CreateObjects(gst_BarnacleNonBreeder,NULL,gs,1);
     }
     // Create the greylag families
     for (int i = 0; i<m_migrationnumbers[gs_Greylag][0]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Greylag].size());
         gs->m_roost = m_roosts[gs_Greylag][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         gs->m_sex = true;
         gs->m_weight = cfg_goose_gl_baseweight.value();
         gs->m_family = true;
         gs->m_grpsize = 2 + m_youngdist[ random( youngno) ];  // Values for Pinkfeet in lack of better data
         CreateObjects(gst_GreylagFamilyGroup, NULL, gs, 1);
     }
     // Create the greylag non-breeders
     for (int i = 0; i<m_migrationnumbers[gs_Greylag][1]; i++)
     {
         // Find the roost location
         int index = random((int) m_roosts[gs_Greylag].size());
         gs->m_roost = m_roosts[gs_Greylag][index];
         gs->m_x = gs->m_roost.m_x;
         gs->m_y = gs->m_roost.m_y;
         if (g_rand_uni() < cfg_goose_gl_sexratio.value()) gs->m_sex = true; else gs->m_sex = false; // true = male, false = female
         gs->m_weight = cfg_goose_gl_baseweight.value();
         gs->m_family = false;
         CreateObjects(gst_GreylagNonBreeder,NULL,gs,1);
     }
     delete gs;
 }

References cfg_goose_bn_arrivedateend, cfg_goose_bn_arrivedatestart, cfg_goose_bn_baseweight, cfg_goose_bn_leavingdateend, cfg_goose_bn_sexratio, cfg_goose_bn_springmigdateend, cfg_goose_bn_springmigdatestart, cfg_goose_bn_springmigrate, cfg_goose_gl_arrivedateend, cfg_goose_gl_arrivedatestart, cfg_goose_gl_baseweight, cfg_goose_gl_leavingdateend, cfg_goose_gl_sexratio, cfg_goose_gl_springmigdateend, cfg_goose_gl_springmigdatestart, cfg_goose_gl_springmigrate, cfg_goose_pf_arrivedateend, cfg_goose_pf_arrivedatestart, cfg_goose_pf_baseweight, cfg_goose_pf_leavingdateend, cfg_goose_pf_sexratio, cfg_goose_pf_springmigdateend, cfg_goose_pf_springmigdatestart, cfg_goose_pf_springmigrate, CreateObjects(), g_rand_uni, GetImmigrationNumbers(), gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, struct_Goose::m_family, struct_Goose::m_GPM, struct_Goose::m_grpsize, struct_Goose::m_L, m_migrationnumbers, struct_Goose::m_roost, m_roosts, Population_Manager::m_SeasonNumber, struct_Goose::m_sex, Population_Manager::m_TheLandscape, struct_Goose::m_weight, APoint::m_x, struct_Goose::m_x, APoint::m_y, struct_Goose::m_y, m_youngdist, random(), Landscape::SupplyDayInYear(), CfgInt::value(), CfgFloat::value(), and CfgBool::value().

Referenced by DoFirst().

◆ DoLast()

void Goose_Population_Manager::DoLast ( void )

protectedvirtual

Things to do after the EndStep.

The first job of DoLast is to update grain status in the forage locations.
If it is end of day, then max goose numbers are relayed to the field elements, then to inform the landscape of changes in grain and maize densities as a result of goose feeding. This is done here rather than have the geese interact directly with the landscape elements for efficiency, since landscape elements will only be updated once a day, and after the geese are finished. This also means fewer calculations and indirections.
If there is no grain or maize to deplete this does nothing.

Todo:: Where is the grazing resource depleted?
Once that is done then we need to produce output - we produce three output files here - the first with the goose information at individual level. The second is field information about where the geese forage. In both cases the data is written to these files when between start and end year, and start and end day (inclusive).
The third output is the a description of the population sizes of each type of goose we simulate (these are numbers extant in the area being simulated).

Reimplemented from Population_Manager.

                                       {
     for (unsigned i = 0; i < m_GooseForageLocations.size(); i++) {
         m_GooseForageLocations[ i ].UpdateKJ();
     }
     int daylength = m_TheLandscape->SupplyDaylength();
     // Since the daylight starts at m_daytime == 0 and the daylength varies, we are recording geese at a timepoint by dividing the day by a specified value. E.g. to get noon, we divide by 2
     int rectime = int(round( daylength / cfg_goose_TimedCounts.value() ));
     rectime -= rectime % 10;  // To get a timestep point
     if (rectime == m_daytime) {
         int sz = (int)m_GooseForageLocations.size();
         for (int i = 0; i < sz; i++) {
             int pref = m_GooseForageLocations[i].GetPolygonref();
             int goose_numbers = m_GooseForageLocations[i].GetGooseNumbers();
             m_TheLandscape->RecordGooseNumbersTimed(pref, goose_numbers);
             for (unsigned j = 0; j < gs_foobar; j++) {
                 int goose_numbers_timed = m_GooseForageLocations[i].GetBirds((GooseSpecies)j);
                 m_TheLandscape->RecordGooseSpNumbersTimed(pref, goose_numbers_timed, (GooseSpecies)j);
                 int roost_dist = int( m_GooseForageLocations[i].GetRoostDist((GooseSpecies)j));
                 m_TheLandscape->RecordGooseRoostDist(pref, roost_dist, (GooseSpecies)j);
             }
         }
     }
     int day = m_TheLandscape->SupplyDayInYear();
     if (day == 300)
     {
         rectime = int(round(daylength / cfg_goose_TimedCounts.value()));
         rectime -= rectime % 10;  // To get a timestep point
         if (rectime == m_daytime) 
         {
             XYDump();
         }
     }
     if (m_daytime == 1430) // Last chance before sunrise (start of next day)
     {
         day = m_TheLandscape->SupplyDayInYear(); // **CJT** This looks to be superfluous
         if (day == 183) m_SeasonNumber++;
  
         int sz = (int)m_GooseForageLocations.size();
         for (int i = 0; i < sz; i++) {
             m_TheLandscape->RecordGooseNumbers( m_GooseForageLocations[ i ].GetPolygonref(), m_GooseForageLocations[ i ].GetMaxBirdsPresent() );
             for (unsigned j = 0; j < gs_foobar; j++) {
                 m_TheLandscape->RecordGooseSpNumbers( m_GooseForageLocations[ i ].GetPolygonref(), m_GooseForageLocations[ i ].GetMaxSpBirdsPresent( (GooseSpecies)j ), (GooseSpecies)j );
             }
             // Remove bird records from the location and do a debug check on any birds remaining.
             m_GooseForageLocations[ i ].ClearBirds();
         }
         // If there are any geese and the output is required we record output:
         int anygeese = 0;
         for (int i = 0; i < gst_foobar; ++i) {
             anygeese = (int) GetLiveArraySize( i );
             if (anygeese > 0) {
                 break;
             }
         }
         if (anygeese > 0) {
             if (cfg_goose_FieldForageInfo.value()) {
                 GooseFieldForageInfoOutput();
             }
             if (cfg_goose_EnergyRecord.value()) {
                 GooseEnergyRecordOutput();
                 ClearGooseForagingTimeStats();
                 ClearGooseFlightDistanceStats();
                 ClearGooseDailyEnergyBudgetStats();
                 ClearGooseDailyEnergyBalanceStats();
             }
             if (cfg_goose_WeightStats.value()) {
                 if ((day + 1) % 7 == 0)  // Only do weekly mean of the weights. +1 to avoid day 0 problems
                 {
                     GooseWeightStatOutput();  // Here we record the weight stats for the day
                     ClearGooseWeightStats();  // and here we reset them.
                 }
             }
             if (cfg_goose_IndLocCounts.value()) {
                 GooseIndLocCountOutput();  // Here we record the individual forage location counts stats for the day
                 ClearIndLocCountStats();  // and here we reset them.
             }
             if (cfg_goose_StateStats.value())
             {
                 StateStatOutput();
                 ClearStateStats();
             }
             if (cfg_goose_PopulationDescriptionON.value()) {
                 GoosePopulationDescriptionOutput();
             }
             if (cfg_goose_LeaveReasonStats.value()) {
                 GooseLeaveReasonStatOutput();
                 ClearGooseLeaveReasonStats();
             }
         }
         // Update forage:
         for (int i = 0; i < sz; i++) {
             int TheForageLocationPolyref = m_GooseForageLocations[ i ].GetPolygonref();
             double poly_grain = m_TheLandscape->SupplyBirdSeedForage( TheForageLocationPolyref );
             if (poly_grain > 0) {
                 m_TheLandscape->SetBirdSeedForage( TheForageLocationPolyref, m_GooseForageLocations[ i ].GetGrainDensity() );
             }
             double poly_maize = m_TheLandscape->SupplyBirdMaizeForage( TheForageLocationPolyref );
             if (poly_maize > 0) {
                 m_TheLandscape->SetBirdMaizeForage( TheForageLocationPolyref, m_GooseForageLocations[ i ].GetMaizeDensity() );
             }
             if (m_GooseForageLocations[ i ].GetGrazedBiomass() > 0) {
                 m_TheLandscape->GrazeVegetationTotal( TheForageLocationPolyref, m_GooseForageLocations[ i ].GetGrazedBiomass() );
                 m_GooseForageLocations[ i ].ResetGrazing();
             }
         }
     }
     // Record habitat use
     if (GetDayTime() == cfg_gooseHabitatUsetime.value())
     {
         // Need to cycle through all the geese and ask where they foraged last
         for (int i = 0; i < gst_foobar; i++)
         {
             Goose_Base* gb;
             int sz = int(GetLiveArraySize(i));
             for (int j = 0; j < sz; j++)
             {
                 // This records what the geese fed on - provides the habitat use output
                 gb = (dynamic_cast<Goose_Base*>(TheArray[i][j]));
                 TMaxIntakeSource src = gb->GetMaxIntakeSource();
                 if (src.m_maxintakesource != tomis_foobar)
                 {
                     RecordHabitatUse(src.m_maxintakesource, gb->GetSpecies(), gb->GetGroupsize());
                     // Below the same kind of output, but now mimicing the field observations
                     TTypeOfMaxIntakeSource res = tomis_foobar;
                     // If it is maize it is maize if in stubble
                     if (src.m_maxintakesource == tomis_sowncrop) res = tomis_sowncrop;
                     else if ((((src.m_prevsowncrop == tov_Maize) || (src.m_prevsowncrop == tov_MaizeSilage))) && (src.m_instubble)) res = tomis_maize;
                     else if (src.m_instubble) {
                         if (src.m_iscereal) res = tomis_grain;
                         else if (m_TheLandscape->SupplyIsGrass2(src.m_veg)) res = tomis_grass; // post silage cut
                     }
                     else res = tomis_grass;
                     RecordHabitatUseFieldObs(res, gb->GetSpecies(), gb->GetGroupsize());
                 }
             }
         }
         // Write the record
         if (g_date->GetDayInMonth() == 1)
         {
             GooseHabitatUseOutput();
             GooseHabitatUseFieldObsOutput();
         }
     }
 }

References cfg_goose_EnergyRecord, cfg_goose_FieldForageInfo, cfg_goose_IndLocCounts, cfg_goose_LeaveReasonStats, cfg_goose_PopulationDescriptionON, cfg_goose_StateStats, cfg_goose_TimedCounts, cfg_goose_WeightStats, cfg_gooseHabitatUsetime, ClearGooseDailyEnergyBalanceStats(), ClearGooseDailyEnergyBudgetStats(), ClearGooseFlightDistanceStats(), ClearGooseForagingTimeStats(), ClearGooseLeaveReasonStats(), ClearGooseWeightStats(), ClearIndLocCountStats(), ClearStateStats(), g_date, Calendar::GetDayInMonth(), GetDayTime(), GetGrainDensity(), Goose_Base::GetGroupsize(), Population_Manager::GetLiveArraySize(), GetMaizeDensity(), Goose_Base::GetMaxIntakeSource(), Goose_Base::GetSpecies(), GooseEnergyRecordOutput(), GooseFieldForageInfoOutput(), GooseHabitatUseFieldObsOutput(), GooseHabitatUseOutput(), GooseIndLocCountOutput(), GooseLeaveReasonStatOutput(), GoosePopulationDescriptionOutput(), GooseWeightStatOutput(), Landscape::GrazeVegetationTotal(), gst_foobar, m_daytime, m_GooseForageLocations, TMaxIntakeSource::m_instubble, TMaxIntakeSource::m_iscereal, TMaxIntakeSource::m_maxintakesource, TMaxIntakeSource::m_prevsowncrop, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, TMaxIntakeSource::m_veg, Landscape::RecordGooseNumbers(), Landscape::RecordGooseNumbersTimed(), Landscape::RecordGooseRoostDist(), Landscape::RecordGooseSpNumbers(), Landscape::RecordGooseSpNumbersTimed(), RecordHabitatUse(), RecordHabitatUseFieldObs(), Landscape::SetBirdMaizeForage(), Landscape::SetBirdSeedForage(), StateStatOutput(), Landscape::SupplyBirdMaizeForage(), Landscape::SupplyBirdSeedForage(), Landscape::SupplyDayInYear(), Landscape::SupplyDaylength(), Landscape::SupplyIsGrass2(), Population_Manager::TheArray, tomis_foobar, tomis_grain, tomis_grass, tomis_maize, tomis_sowncrop, tov_Maize, tov_MaizeSilage, CfgInt::value(), CfgBool::value(), and XYDump().

◆ FindClosestRoost()

void Goose_Population_Manager::FindClosestRoost	(	int &	a_x,
		int &	a_y,
		unsigned	a_type
	)

Changes a_x & a_y to the location of the nearest roost of a_type to a_x, a_y.

 {
     int answer = 0;
     int rx = m_roosts[a_type][0].m_x;
     int ry = m_roosts[a_type][0].m_y;
     int dist = g_AlmassMathFuncs.CalcDistPythagoras(rx, ry, a_x, a_y);
     for (unsigned i=1; i<m_roosts[a_type].size(); i++)
     {
         rx = m_roosts[a_type][i].m_x;
         ry = m_roosts[a_type][i].m_y;
         int di = g_AlmassMathFuncs.CalcDistPythagoras( rx, ry, a_x, a_y );
         if (di<dist) answer = i;
     }
     a_x = m_roosts[a_type][answer].m_x;
     a_y = m_roosts[a_type][answer].m_y;
 }

References ALMaSS_MathFuncs::CalcDistPythagoras(), g_AlmassMathFuncs, and m_roosts.

Referenced by Goose_Barnacle_Base::ChangeRoost(), Goose_Greylag_Base::ChangeRoost(), and Goose_Pinkfoot_Base::ChangeRoost().

◆ ForageLocationInUse()

int Goose_Population_Manager::ForageLocationInUse ( int a_polyref )

Tests if a forage location is currently in use, if so returns the index to it.

Parameters

[in] a_polyref is the polygon reference number that identifies the field for foraging

Returns: Returns and integer which is the index in the vector if the polyref is found, otherwise returns -1 Searches the whole m_GooseForageLocations vector for a match for a_polyref. Stops looking if one is found.

 {
     int index = -1;
     int sz = (int) m_GooseForageLocations.size();
     for (int i=0; i< sz; i++)
     {
         if (m_GooseForageLocations[i].GetPolygonref() == a_polyref )
         {
             index = i;
             break;
         }
     }
     return index;
 }

References m_GooseForageLocations.

Referenced by AddGeeseToForageLocationP(), BirdsShot(), BirdsToShootAtPoly(), GetForageLocIndex(), and Goose_Base::st_ChooseForageLocation().

◆ GetBirdsAtForageLoc()

int Goose_Population_Manager::GetBirdsAtForageLoc	(	int	a_index,
		GooseSpeciesType	a_type
	)

inline

Returns the number of birds at a forage location - given by a poly ref.

                                                                   {
         return m_GooseForageLocations[a_index].GetBirds(a_type);
     }

References m_GooseForageLocations.

Referenced by Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

◆ GetDaylightLeft()

int Goose_Population_Manager::GetDaylightLeft ( )

inline

Get the daylight minutes left today.

412 { return m_daylightleft; }

References m_daylightleft.

◆ GetDayTime()

int Goose_Population_Manager::GetDayTime ( )

inline

Get the time of day (in minutes). For the goose model, sunrise is defined as m_daytime == 0. Hence this function returns the number of minutes since sunrise.

408 { return m_daytime; }

References m_daytime.

Referenced by DoLast(), Goose_Base::st_ChooseForageLocation(), Goose_Base::st_Forage(), Goose_Base::st_Roost(), Goose_Base::StartDay(), and TheAOROutputProbe().

◆ GetDistToClosestRoost()

double Goose_Population_Manager::GetDistToClosestRoost	(	int	a_x,
		int	a_y,
		unsigned	a_type
	)

Returns the distance in to the nearest roost of a_type in meters.

 {
     int rx = m_roosts[a_type][0].m_x;
     int ry = m_roosts[a_type][0].m_y;
     int dist = g_AlmassMathFuncs.CalcDistPythagoras(rx, ry, a_x, a_y);
     for (unsigned i = 1; i<m_roosts[a_type].size(); i++)
     {
         rx = m_roosts[a_type][i].m_x;
         ry = m_roosts[a_type][i].m_y;
         int di = g_AlmassMathFuncs.CalcDistPythagoras(rx, ry, a_x, a_y);
         if (di < dist) {
             dist = di;
         }
     }
     return dist;
 }

References ALMaSS_MathFuncs::CalcDistPythagoras(), g_AlmassMathFuncs, and m_roosts.

Referenced by NewForageLocation().

◆ GetFeedingRate()

double Goose_Population_Manager::GetFeedingRate	(	double	a_graindensity,
		GooseSpecies	a_species
	)

inline

Get the forage rate based on the grain density.

Parameters

[in]	a_graindensity	The grain density (grain/m2) on the forage location
[in]	a_species	The type of goose species

Returns: The species specific intake rate (kJ/min) when feeding on grain

Unpublished curve from Nolet. o:/ST_GooseProject/Field data/Fugledata/Functional response pink-feet.xlsx This curve has already taken digestibility, energy content and assimilation into account.

     {
         if (a_species == gs_Greylag) return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity) * 1.21;
         else if (a_species == gs_Pinkfoot) return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity);
         else return m_IntakeRateVSGrainDensity_PF->GetY(a_graindensity) * 0.74;
     }

References CurveClass::GetY(), and m_IntakeRateVSGrainDensity_PF.

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

◆ GetForageGooseDensity()

double Goose_Population_Manager::GetForageGooseDensity ( int a_index )

inline

Returns the total goose density for a forage location.

492 { return m_GooseForageLocations[a_index].GetGooseDensity(); }

References m_GooseForageLocations.

Referenced by Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

◆ GetForageGrazing()

double Goose_Population_Manager::GetForageGrazing	(	int	a_index,
		int	gs
	)

inline

Returns the forage density for a forage location and goose type. This is species specific.

496 { return m_GooseForageLocations[a_index].GetGrazing(gs); }

References m_GooseForageLocations.

◆ GetForageLocation()

GooseActiveForageLocation* Goose_Population_Manager::GetForageLocation ( unsigned int a_index )

inline

Returns a pointer to the forage location indexed by index.

                                                                        {
         if ((m_GooseForageLocations.size() == 0) || (m_GooseForageLocations.size() <= a_index)) return NULL; else return &m_GooseForageLocations[a_index];
     }

References m_GooseForageLocations.

Referenced by Goose_Base::st_ChooseForageLocation(), and XYDump().

◆ GetForageLocIndex()

int Goose_Population_Manager::GetForageLocIndex	(	GooseSpecies	a_species,
		int	a_x,
		int	a_y
	)

Get a forage location for my species (picked randomly among the active locations)

Todo:: add documentation

                                                                                           {
     int forageindex = -1;
     std::vector<int> fields;
     int sz = (int)m_GooseForageLocations.size();
     if (sz > 0) {
         for (int i = 0; i < sz; i++) {
             int birds = m_GooseForageLocations[ i ].GetBirds( a_species );
             if (birds > 0) {
                 int index = m_GooseForageLocations[ i ].GetPolygonref();
                 fields.push_back( index );
             }
         }
         if (fields.size() != 0) {
             // Find the distances to those forage locations
             int answer = random(int(fields.size()));
             int max_dist = 43266;  // diagonal of Vejlerne
             int fx, fy;
             for (int i = 0; i<fields.size(); i++) {
                 fx = m_TheLandscape->SupplyCentroidX( fields[ i ] );
                 fy = m_TheLandscape->SupplyCentroidY( fields[ i ] );
                 int di = g_AlmassMathFuncs.CalcDistPythagoras( fx, fy, a_x, a_y );
                 if (g_rand_uni() < exp(-(di / max_dist) * cfg_goose_dist_weight_power.value()))
                 {
                     answer = i;
                 } 
             }
             int polyref = fields[ answer ];
             forageindex = ForageLocationInUse( polyref );
         }
     }
     return forageindex;
 }

References ALMaSS_MathFuncs::CalcDistPythagoras(), cfg_goose_dist_weight_power, ForageLocationInUse(), g_AlmassMathFuncs, g_rand_uni, m_GooseForageLocations, Population_Manager::m_TheLandscape, random(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), and CfgFloat::value().

Referenced by Goose_Base::st_ChooseForageLocation(), and XYDump().

◆ GetForageRateDensity()

double Goose_Population_Manager::GetForageRateDensity ( double a_foragedensity )

inline

Get the forage intake rate for a forage density.

488 { return m_ForageRateVSGooseDensity->GetY(a_foragedensity); }

References CurveClass::GetY(), and m_ForageRateVSGooseDensity.

Referenced by Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

◆ GetGrainDensity()

double Goose_Population_Manager::GetGrainDensity ( int a_index )

inline

Returns the forage density for a forage location.

500 { return m_GooseForageLocations[a_index].GetGrainDensity(); }

References m_GooseForageLocations.

Referenced by DoLast().

◆ GetImmigrationNumbers()

void Goose_Population_Manager::GetImmigrationNumbers	(	GooseSpecies	a_goose,
		bool	a_season
	)

protected

Get the numbers to immigrate.

 {
     if (a_goose == gs_Pinkfoot && fall)
     {
         int pfnum = cfg_goose_pf_startnos.value();
         int pfyoung = (int)floor(pfnum * cfg_goose_pf_young_proportion.value());
         int pffam = (int)floor(pfyoung / 4); // On average the families have 4 young
         int pfnb = pfnum - (pffam + pfyoung);  // The familes are then two adults plus their young
  
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (pffam / ((1 + cfg_goose_pf_arrivedateend.value()) - cfg_goose_pf_arrivedatestart.value())));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (pfnb / ((1 + cfg_goose_pf_arrivedateend.value()) - cfg_goose_pf_arrivedatestart.value())));
     }
     if (a_goose == gs_Pinkfoot && !fall)
     {
         int pfnum = cfg_goose_pf_springmignos.value();
         int pfyoung = (int)floor(pfnum * cfg_goose_pf_young_proportion.value());
         int pffam = (int)floor(pfyoung / 4); // On average the families have 4 young
         int pfnb = pfnum - (pffam + pfyoung);  // The familes are then two adults plus their young
  
         int start = cfg_goose_pf_springmigdatestart.value();
         int end = cfg_goose_pf_springmigdateend.value();
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (pffam / ((1 + end) - start)));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (pfnb / ((1 + end) - start)));
     }
     if (a_goose == gs_Barnacle && fall)
     {
         int bnnum = cfg_goose_bn_startnos.value();
         int bnyoung = (int)floor(bnnum * cfg_goose_bn_young_proportion.value());
         int bnfam = (int)floor(bnyoung / 4); // On average the families have 4 young
         int bnnb = bnnum - (bnfam + bnyoung);  // The familes are then two adults plus their young
  
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (bnfam / ((1 + cfg_goose_bn_arrivedateend.value()) - cfg_goose_bn_arrivedatestart.value())));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (bnnb / ((1 + cfg_goose_bn_arrivedateend.value()) - cfg_goose_bn_arrivedatestart.value())));
     }
     if (a_goose == gs_Barnacle && !fall)
     {
         int bnnum = cfg_goose_bn_springmignos.value();
         int bnyoung = (int)floor(bnnum * cfg_goose_bn_young_proportion.value());
         int bnfam = (int)floor(bnyoung / 4); // On average the families have 4 young
         int bnnb = bnnum - (bnfam + bnyoung);  // The familes are then two adults plus their young
  
         int start = cfg_goose_bn_springmigdatestart.value();
         int end = cfg_goose_bn_springmigdateend.value();
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (bnfam / ((1 + end) - start)));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (bnnb / ((1 + end) - start)));
     }
     if (a_goose == gs_Greylag && fall)
     {
         int glnum = cfg_goose_gl_startnos.value();
         int glyoung = (int)floor(glnum * cfg_goose_gl_young_proportion.value());
         int glfam = (int)floor(glyoung / 4); // On average the families have 4 young
         int glnb = glnum - (glfam + glyoung);  // The familes are then two adults plus their young
  
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (glfam / ((1 + cfg_goose_gl_arrivedateend.value()) - cfg_goose_gl_arrivedatestart.value())));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (glnb / ((1 + cfg_goose_gl_arrivedateend.value()) - cfg_goose_gl_arrivedatestart.value())));
     }
     if (a_goose == gs_Greylag && !fall)
     {
         int glnum = cfg_goose_gl_springmignos.value();
         int glyoung = (int)floor(glnum * cfg_goose_gl_young_proportion.value());
         int glfam = (int)floor(glyoung / 4); // On average the families have 4 young
         int glnb = glnum - (glfam + glyoung);  // The familes are then two adults plus their young
  
         int start = cfg_goose_gl_springmigdatestart.value();
         int end = cfg_goose_gl_springmigdateend.value();
         m_migrationnumbers[a_goose][0] = (int)floor(0.5 + (glfam / ((1 + end) - start)));
         m_migrationnumbers[a_goose][1] = (int)floor(0.5 + (glnb / ((1 + end) - start)));
     }
 }

References cfg_goose_bn_arrivedateend, cfg_goose_bn_arrivedatestart, cfg_goose_bn_springmigdateend, cfg_goose_bn_springmigdatestart, cfg_goose_bn_springmignos, cfg_goose_bn_startnos, cfg_goose_bn_young_proportion, cfg_goose_gl_arrivedateend, cfg_goose_gl_arrivedatestart, cfg_goose_gl_springmigdateend, cfg_goose_gl_springmigdatestart, cfg_goose_gl_springmignos, cfg_goose_gl_startnos, cfg_goose_gl_young_proportion, cfg_goose_pf_arrivedateend, cfg_goose_pf_arrivedatestart, cfg_goose_pf_springmigdateend, cfg_goose_pf_springmigdatestart, cfg_goose_pf_springmignos, cfg_goose_pf_startnos, cfg_goose_pf_young_proportion, m_migrationnumbers, start, CfgInt::value(), and CfgFloat::value().

Referenced by DoImmigration().

◆ GetIsDaylight()

int Goose_Population_Manager::GetIsDaylight ( )

inline

Is it daylight hours? Daylight starts at m_daytime == 0.

416 { return m_daylight; }

References m_daylight.

Referenced by Goose_Base::st_Roost().

◆ GetLeader()

Goose_Base * Goose_Population_Manager::GetLeader	(	APoint	a_roost,
		GooseSpecies	a_species
	)

Asks for a pointer to a goose that can be followed.

When leaving the roost in the morning we have the option to either follow another bird or go exploring on our own./n If we follow another bird this function will find a bird to follow (a leader). It is a prerequisite that the leader is from the same roost as the bird following and that the leader have found a suitable forage location.

Parameters

[in]	a_roost	The roost of the follower as a point.
[in]	a_species	The species of the follower.

Returns: A pointer to the leader.

 {
     // Need to start a random point in our list of birds
     // We know the total number of bird objects of the species, so assume they are one circular long list 
     // 
     Goose_Base* GBp;
     int sz1 = 0;
     int sz2 = 0;
     int base = (int)a_species * 2;  // To get the position of the speciesFamilyGroup in TheArray
     int base1 = 1 + ((int)a_species * 2);  // the speciesNonBreeder is always the next one
     switch (a_species) {
     case gs_Pinkfoot:
         sz1 = int(GetLiveArraySize(gst_PinkfootFamilyGroup));
         sz2 = int(GetLiveArraySize(gst_PinkfootNonBreeder));
         break;
     case gs_Barnacle:
         sz1 = int(GetLiveArraySize(gst_BarnacleFamilyGroup));
         sz2 = int(GetLiveArraySize(gst_BarnacleNonBreeder));
         break;
     case gs_Greylag:
         sz1 = int(GetLiveArraySize(gst_GreylagFamilyGroup));
         sz2 = int(GetLiveArraySize(gst_GreylagNonBreeder));
         break;
     };
     int total = sz1 + sz2;
     int start = random(total);
     for (int g = 0; g < total; g++)  // Loops until a goose which does not return -1 for the forage location index is found
     {
         int index;
         if (start == total) start = 0;
         if (start < sz1) {
             index = start;
             GBp = dynamic_cast<Goose_Base*>(TheArray[base][index]);
             if ((GBp->GetRoost().m_x == a_roost.m_x) && (GBp->GetRoost().m_y == a_roost.m_y) && (GBp->GetForageLocIndex() != -1)) {
                 return GBp;
             }
         }
         else {
             index = start - sz1;
             GBp = dynamic_cast<Goose_Base*>(TheArray[base1][index]);
             if ((GBp->GetRoost().m_x == a_roost.m_x) && (GBp->GetRoost().m_y == a_roost.m_y) && (GBp->GetForageLocIndex() != -1)) {
                 return GBp;
             }
         }
         start++;
     }
     return NULL;
 }

References Goose_Base::GetForageLocIndex(), Population_Manager::GetLiveArraySize(), Goose_Base::GetRoost(), gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, APoint::m_x, APoint::m_y, random(), start, and Population_Manager::TheArray.

Referenced by Goose_Base::st_ChooseForageLocation().

◆ GetMaizeDensity()

double Goose_Population_Manager::GetMaizeDensity ( int a_index )

inline

Returns the maize forage density for a forage location.

                                         {
         return m_GooseForageLocations[a_index].GetMaizeDensity();
     }

References m_GooseForageLocations.

Referenced by DoLast().

◆ GetMaizeFeedingRate()

double Goose_Population_Manager::GetMaizeFeedingRate	(	double	a_maizedensity,
		GooseSpecies	a_species
	)

inline

Get the forage rate when feeding on maize.

Parameters

[in]	a_maizedensity	The maize density in kJ/m2
[in]	a_species	The type of goose species

Returns: The species specific intake rate when feeding on maize

Functional response for geese feeding on maize is currently lacking. The curve used here is based on field observations of barnacle geese made with wildlife cameras in Jutland in 2015. Assimilation for energy is accounted for in the functional response curce. Value found for Bewick's swans from Nolet, B. unpubl. For greylag and pinkfeet the value is scaled based on the relationship between

                                                                               {
         if (a_species == gs_Greylag) return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity) * 1.64;
         else if (a_species == gs_Pinkfoot) return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity) * 1.35;
         else return m_IntakeRateVSMaizeDensity_BN->GetY(a_maizedensity);
     }

References CurveClass::GetY(), and m_IntakeRateVSMaizeDensity_BN.

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

◆ GetNumberOfForageLocs()

int Goose_Population_Manager::GetNumberOfForageLocs ( void )

inline

Get the number of forage locations.

560 { return int(m_GooseForageLocations.size()); }

References m_GooseForageLocations.

◆ GetThermalCosts()

double Goose_Population_Manager::GetThermalCosts ( GooseSpecies a_goose )

inline

Get daily thermal costs const.

556 { return m_thermalcosts[a_goose]; }

References m_thermalcosts.

Referenced by Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and Goose_Base::StartDay().

◆ GooseEnergyRecordOutput()

void Goose_Population_Manager::GooseEnergyRecordOutput ( )

protected

Produces output to a standard file describing the number of birds foraging at each field and the field conditions.

 {
     int day = m_TheLandscape->SupplyGlobalDate();
     int day_length = m_TheLandscape->SupplyDaylength();
         for (int i = 0; i < gs_foobar; ++i)
         {
             std::string gs = GooseToString((GooseSpecies)i);
             (*m_GooseEnergeticsDataFile)
                 << m_SeasonNumber << '\t'
                 << day << '\t'
                 << gs << '\t'
                 << m_ForagingTimeStats[i].get_meanvalue() << '\t'
                 << m_ForagingTimeStats[i].get_SE() << '\t'
                 << m_FlightDistanceStats[i].get_meanvalue() << '\t'
                 << m_FlightDistanceStats[i].get_SE() << '\t'
                 << m_DailyEnergyBudgetStats[i].get_meanvalue() << '\t'
                 << m_DailyEnergyBudgetStats[i].get_SE() << '\t'
                 << m_DailyEnergyBalanceStats[i].get_meanvalue() << '\t'
                 << m_DailyEnergyBalanceStats[i].get_SE() << '\t'
                 << day_length << endl;
         }
 }

References SimpleStatistics::get_meanvalue(), SimpleStatistics::get_SE(), GooseToString(), m_DailyEnergyBalanceStats, m_DailyEnergyBudgetStats, m_FlightDistanceStats, m_ForagingTimeStats, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyDaylength(), and Landscape::SupplyGlobalDate().

Referenced by DoLast().

◆ GooseFieldForageInfoOutput()

void Goose_Population_Manager::GooseFieldForageInfoOutput ( )

protected

Produces output to a standard file describing the energetic state of all individuals of the goose populations.

The information needed here is in the landscape. We need to trawl through all the fields and record those that have suitable openness scores and food for geese

 {
     int Day = m_TheLandscape->SupplyGlobalDate();
  
     GooseFieldList* afieldlist = m_TheLandscape->GetGooseFields(cfg_goose_MinForageOpenness.value());
     unsigned sz = (unsigned) afieldlist->size();
     if (cfg_goose_runtime_reporting.value())
     {
         for (unsigned f = 0; f < sz; f++)
         {
             // Only write if there were any geese
             if ((*afieldlist)[f].geese > 0) {
                 (*m_GooseFieldForageDataFile)
                     << m_SeasonNumber << '\t'
                     << Day << '\t'
                     << (*afieldlist)[f].geese << '\t';
                     for (int i = 0; i < gs_foobar; ++i)
                     {
                         (*m_GooseFieldForageDataFile) 
                             << (*afieldlist)[f].geesesp[i] << '\t'
                             << (*afieldlist)[f].geesespTimed[i] << '\t'
                             << (*afieldlist)[f].roostdists[i] << '\t';
                     }
                     (*m_GooseFieldForageDataFile) << (*afieldlist)[f].polyref << endl;
             }
         }
     }
     if (!cfg_goose_runtime_reporting.value()) {
         for (unsigned f = 0; f < sz; f++)
         {
             int pref = (*afieldlist)[f].polyref;
             int utm_x = 484378 + m_TheLandscape->SupplyCentroidX(pref);
             int utm_y = 6335161 - m_TheLandscape-> SupplyCentroidY(pref);
             (*m_GooseFieldForageDataFile)
                 << m_SeasonNumber << '\t'
                 << Day << '\t'
                 << pref << '\t'
                 << utm_x << '\t'
                 << utm_y << '\t'
                 << (*afieldlist)[f].geese << '\t'
                 << (*afieldlist)[f].geeseTimed << '\t'
                 << (*afieldlist)[f].openness << '\t';
             for (int i = 0; i < gs_foobar; ++i)
             {
                 (*m_GooseFieldForageDataFile)
                     << (*afieldlist)[f].geesesp[i] << '\t'
                     << (*afieldlist)[f].geesespTimed[i] << '\t'
                     << (*afieldlist)[f].roostdists[i] << '\t'
                     << (*afieldlist)[f].grass[i] << '\t';
             }
             (*m_GooseFieldForageDataFile)
                 << (*afieldlist)[f].grain << '\t'
                 << (*afieldlist)[f].maize << '\t'
                 << (*afieldlist)[f].vegtypechr << '\t'
                 << (*afieldlist)[f].vegheight << '\t'
                 << (*afieldlist)[f].digestability << '\t'
                 << (*afieldlist)[f].vegphase << '\t'
                 << (*afieldlist)[f].previouscrop << '\t'
                 << (*afieldlist)[f].lastsownveg << endl;
         }
     }
     delete afieldlist;
 }

References cfg_goose_MinForageOpenness, cfg_goose_runtime_reporting, Landscape::GetGooseFields(), Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyCentroidX(), Landscape::SupplyGlobalDate(), CfgFloat::value(), and CfgBool::value().

Referenced by DoLast().

◆ GooseHabitatUseFieldObsOutput()

void Goose_Population_Manager::GooseHabitatUseFieldObsOutput ( )

protected

Outputs simple stats for the goose habitat use but using rules to mimic field observations.

 {
     for (int i = 0; i < gs_foobar; ++i)
     {
         double pct[tomis_foobar];
         int count = 0;
         for (int h = 0; h < tomis_foobar; h++) {
             count += m_HabitatUseFieldObsStats[i* tomis_foobar + h];
             pct[h] = 0;
         }
         for (int h = 0; h < tomis_foobar; h++) {
             if (count > 0) pct[h] = m_HabitatUseFieldObsStats[i* tomis_foobar + h] / double(count); else pct[h] = 0;
         }
  
         std::string gs = GooseToString((GooseSpecies)i);
         (*m_GooseHabitatUseFieldObsFile)
             << m_SeasonNumber << '\t'
             << m_TheLandscape->SupplyGlobalDate() << '\t'
             << m_TheLandscape->SupplyDayInYear() << '\t'
             << gs << '\t';
         for (int h = 0; h < tomis_foobar; h++) {
             (*m_GooseHabitatUseFieldObsFile) << pct[h] << '\t';
         }
         (*m_GooseHabitatUseFieldObsFile) << count << endl;
     }
     ClearGooseHabitatUseFieldObsStats();
 }

References ClearGooseHabitatUseFieldObsStats(), GooseToString(), m_HabitatUseFieldObsStats, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyDayInYear(), Landscape::SupplyGlobalDate(), and tomis_foobar.

Referenced by DoLast().

◆ GooseHabitatUseOutput()

void Goose_Population_Manager::GooseHabitatUseOutput ( )

protected

Outputs simple stats for the goose habitat use.

 {
     for (int i = 0; i < gs_foobar; ++i)
     {
         double pct[tomis_foobar];
         int count = 0;
         for (int h = 0; h < tomis_foobar; h++) {
             count += m_HabitatUseStats[i* tomis_foobar + h];
             pct[h] = 0;
         }
         for (int h = 0; h < tomis_foobar; h++) {
             if (count > 0) pct[h] = m_HabitatUseStats[i* tomis_foobar + h] / double(count); else pct[h] = 0;
         }
  
         std::string gs = GooseToString((GooseSpecies)i);
         (*m_GooseHabitatUseFile)
             << m_SeasonNumber << '\t'
             << m_TheLandscape->SupplyGlobalDate() << '\t'
             << m_TheLandscape->SupplyDayInYear() << '\t'
             << gs << '\t';
         for (int h = 0; h < tomis_foobar; h++) {
             (*m_GooseHabitatUseFile) << pct[h] << '\t';
         }
         (*m_GooseHabitatUseFile) << count << endl;
     }
     ClearGooseHabitatUseStats();
 }

References ClearGooseHabitatUseStats(), GooseToString(), m_HabitatUseStats, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyDayInYear(), Landscape::SupplyGlobalDate(), and tomis_foobar.

Referenced by DoLast().

◆ GooseIndLocCountOutput()

void Goose_Population_Manager::GooseIndLocCountOutput ( )

protected

Outputs simple stats for the number of forage locations visited per goose.

 {
     for (int i = 0; i < gs_foobar; ++i)
     {
         std::string gs = GooseToString((GooseSpecies)i);
         (*m_GooseIndLocCountFile)
             << m_SeasonNumber << '\t'
             << m_TheLandscape->SupplyGlobalDate() << '\t'
             << m_TheLandscape->SupplyDayInYear() << '\t'
             << gs << '\t'
             << m_IndividualForageLocationData[i].get_meanvalue() << '\t'
             << m_IndividualForageLocationData[i].get_SE() << '\t'
             << m_IndividualForageLocationData[i].get_N() << endl;
     }
 }

References SimpleStatistics::get_meanvalue(), SimpleStatistics::get_N(), SimpleStatistics::get_SE(), GooseToString(), m_IndividualForageLocationData, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyDayInYear(), and Landscape::SupplyGlobalDate().

Referenced by DoLast().

◆ GooseLeaveReasonStatOutput()

void Goose_Population_Manager::GooseLeaveReasonStatOutput ( )

protected

Outputs simple stats for the reasons for leaving the simulation.

 {
     int day = m_TheLandscape->SupplyGlobalDate();
     int day_in_year = m_TheLandscape->SupplyDayInYear();
     for (int i = 0; i < gst_foobar; ++i)
     {
         std::string gst = GooseTypeToString((GooseSpeciesType)i);
         for (int j = 0; j < tolr_foobar; ++j)
         {
             (*m_GooseLeaveReasonStatsFile)
                 << m_SeasonNumber << '\t'
                 << day << '\t'
                 << day_in_year << '\t'
                 << gst << '\t'
                 << LeaveReasonToString((TTypeOfLeaveReason)j) << '\t'
                 << m_LeaveReasonStats[i][j].get_N() << endl;
         }
     }
 }

References SimpleStatistics::get_N(), GooseTypeToString(), gst_foobar, LeaveReasonToString(), m_LeaveReasonStats, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyDayInYear(), Landscape::SupplyGlobalDate(), and tolr_foobar.

Referenced by DoLast().

◆ GoosePopulationDescriptionOutput()

void Goose_Population_Manager::GoosePopulationDescriptionOutput ( )

protected

Produces output to a standard file describing the state of the goose populations.

Here the first job is to correct the standard output and produce a more detailed description of the population, ie not counting families as one.

 {
     int sz = int(GetLiveArraySize(gst_PinkfootFamilyGroup));
     int pff = 0;
     for (int j = 0; j<sz; j++)
     {
         pff += dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->GetGroupsize();
     }
     sz = int(GetLiveArraySize(gst_BarnacleFamilyGroup));
     int bf = 0;
     for (int j = 0; j<sz; j++)
     {
         bf += dynamic_cast<Goose_Base*>(TheArray[gst_BarnacleFamilyGroup][j])->GetGroupsize();
     }
     sz = int(GetLiveArraySize(gst_GreylagFamilyGroup));
     int gf = 0;
     for (int j = 0; j<sz; j++)
     {
         gf += dynamic_cast<Goose_Base*>(TheArray[gst_GreylagFamilyGroup][j])->GetGroupsize();
     }
     (*m_GoosePopDataFile)
       << m_SeasonNumber << '\t'
       << m_TheLandscape->SupplyGlobalDate() << '\t'
       << pff << '\t'
       << int(GetLiveArraySize(gst_PinkfootNonBreeder)) << '\t'
       << bf << '\t'
       << int(GetLiveArraySize(gst_BarnacleNonBreeder)) << '\t'
       << gf << '\t'
       << int(GetLiveArraySize(gst_GreylagNonBreeder)) << '\t' 
       << m_TheLandscape->SupplySnowDepth() << endl;
 }

References Population_Manager::GetLiveArraySize(), gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Landscape::SupplyGlobalDate(), Landscape::SupplySnowDepth(), and Population_Manager::TheArray.

Referenced by DoLast().

◆ GooseToString()

std::string Goose_Population_Manager::GooseToString ( GooseSpecies a_gs )

protected

Translates gs enum to string

 {
     switch (a_gs)
     {
     case gs_Pinkfoot:
         return "pinkfoot";
     case gs_Barnacle:
         return "barnacle";
     case gs_Greylag:
         return "greylag";
     default:
         return "gs_foobar";
     }
 }

Referenced by GooseEnergyRecordOutput(), GooseHabitatUseFieldObsOutput(), GooseHabitatUseOutput(), GooseIndLocCountOutput(), and GooseWeightStatOutput().

◆ GooseTypeToString()

std::string Goose_Population_Manager::GooseTypeToString ( GooseSpeciesType a_gst )

protected

Translates gst enum to string

 {
     switch (a_gst)
     {
     case gst_PinkfootFamilyGroup:
         return "pinkfoot_family";
     case gst_PinkfootNonBreeder:
         return "pinkfoot_nonbreeder";
     case gst_BarnacleFamilyGroup:
         return "barnacle_family";
     case gst_BarnacleNonBreeder:
         return "barnacle_nonbreeder";
     case gst_GreylagFamilyGroup:
         return "greylag_family";
     case gst_GreylagNonBreeder:
         return "greylag_nonbreeder";
     default:
         return "gst_foobar";
     }
 }

References gst_BarnacleFamilyGroup, gst_BarnacleNonBreeder, gst_GreylagFamilyGroup, gst_GreylagNonBreeder, gst_PinkfootFamilyGroup, and gst_PinkfootNonBreeder.

Referenced by GooseLeaveReasonStatOutput().

◆ GooseWeightStatOutput()

void Goose_Population_Manager::GooseWeightStatOutput ( )

protected

Outputs simple stats for the weights in the population.

 {
     for (int i = 0; i < gs_foobar; ++i)
     {
         std::string gs = GooseToString((GooseSpecies)i);
         (*m_GooseWeightStatsFile)
             << m_SeasonNumber << '\t'
             << m_TheLandscape->SupplyGlobalDate() << '\t'
             << m_TheLandscape->SupplyDayInYear() << '\t'
             << gs << '\t'
             << m_WeightStats[i].get_meanvalue() << '\t'
             << m_WeightStats[i].get_SE() << '\t'
             << m_WeightStats[i].get_N() << endl;
     }
 }

References SimpleStatistics::get_meanvalue(), SimpleStatistics::get_N(), SimpleStatistics::get_SE(), GooseToString(), Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, m_WeightStats, Landscape::SupplyDayInYear(), and Landscape::SupplyGlobalDate().

Referenced by DoLast().

◆ Graze()

void Goose_Population_Manager::Graze	(	double	a_kJ,
		int	a_index
	)

inline

Removes KJ as grams veg biomass from a forage area.

519 { m_GooseForageLocations[a_index].Graze(a_kJ); }

References m_GooseForageLocations.

Referenced by RemoveMaxForageKj().

◆ InGreylagSeason()

bool Goose_Population_Manager::InGreylagSeason ( )

inline

Are we in the greylag hunting season?

420 { return m_GreylagSeason; }

References m_GreylagSeason.

Referenced by BirdsShot(), BirdsToShootAtPoly(), and GooseActiveForageLocation::GetHuntables().

◆ InHuntingSeason()

bool Goose_Population_Manager::InHuntingSeason	(	int	a_day,
		GooseSpecies	a_species
	)

protected

Are we in the hunting season?

The goose hunting season is complicated because it runs over a year boundary (or it can) Particularly the first year of the simulation is tricky, because we start out in January which can be legal hunting season, but the geese don't arrive until the fall.

                                                                                 {
     if (GetSeasonNumber() == 0) {
  
         return false;  // We don't want them to start in January in the first year of the sim.
     }
     if (a_species == gs_Pinkfoot)
     {
         int pfstart = cfg_goose_pinkfootopenseasonstart.value();
         int pfend = cfg_goose_pinkfootopenseasonend.value();
         if (pfstart > pfend) {
             if (a_day < pfstart && a_day > pfend) return false;
             else {
                 return true;  // must be in the first year after the start of season
             }
         }
         else {
             // Season all in one year
             if (a_day < pfstart || a_day > pfend) {
                 return false;
             }
             else {
                 return true;
             }
         }
     }
     else if (a_species == gs_Greylag)
     {
         int glstart = cfg_goose_greylagopenseasonstart.value();
         int glend = cfg_goose_greylagopenseasonend.value();
         if (glstart > glend) {
             if (a_day < glstart && a_day > glend) return false;
             else {
                 return true;  // must be in the first year after the start of season
             }
         }
         else {
             // Season all in one year
             if (a_day < glstart || a_day > glend) {
                 return false;
             }
             else {
                 return true;
             }
         }
     }
     else
     {
         g_msg->Warn(WARN_FILE, "Goose_Population_Manager::InHuntingSeason: ""Species error", "");
         exit(1);
     }
 }

References cfg_goose_greylagopenseasonend, cfg_goose_greylagopenseasonstart, cfg_goose_pinkfootopenseasonend, cfg_goose_pinkfootopenseasonstart, g_msg, Population_Manager::GetSeasonNumber(), CfgInt::value(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by DoFirst().

◆ Init()

void Goose_Population_Manager::Init ( void )

protectedvirtual

Called upon initialization of the simulation. Sets up output files.

Finally opens any output files needed

 {
     if (cfg_ReallyBigOutput_used.value()) {
         OpenTheReallyBigProbe();
     }
     else ReallyBigOutputPrb = 0;
     if (cfg_AOROutput_used.value()) {
         m_AOR_Pinkfeet = new AOR_Probe_Goose(this, m_TheLandscape, "AOR_pinkfoot.txt");
         m_AOR_Barnacles = new AOR_Probe_Goose(this, m_TheLandscape, "AOR_barnacle.txt");
         m_AOR_Greylags = new AOR_Probe_Goose(this, m_TheLandscape, "AOR_greylag.txt");
     }
     m_GooseXYDumpFile = new ofstream("GooseXYDump.txt", ios::out);
     std::vector<std::string> xy_headers;
     xy_headers = { "X", "Y", "poly_ref", "fl_x", "fl_y", "fl_poly" };
     WriteHeaders(m_GooseXYDumpFile, xy_headers);
  
     m_GoosePopDataFile = new ofstream("GoosePopulationData.txt", ios::out);
     std::vector<std::string> pd_headers;
     pd_headers = { "season", "day", "pf_families", "pf_non_breeders", "bn_families",
                     "bn_non_breeders", "gl_families", "gl_non_breeders", "snow_depth" };
     WriteHeaders(m_GoosePopDataFile, pd_headers);
  
     m_GooseWeightStatsFile = new ofstream("GooseWeightStats.txt", ios::out);
     std::vector<std::string> ws_headers = { "season", "day", "day_in_year", "species", "mean_weight", "mean_weight_se", "n" };
     WriteHeaders(m_GooseWeightStatsFile, ws_headers);
  
     m_GooseIndLocCountFile = new ofstream("GooseIndLocCountStats.txt", ios::out);
     std::vector<std::string> ilc_headers = { "season", "day", "day_in_year", "species",
                                             "n_forage_locs", "n_forage_locs_se", "n" };
     WriteHeaders(m_GooseIndLocCountFile, ilc_headers);
  
     m_GooseHabitatUseFile = new ofstream("GooseHabitatUseStats.txt", ios::out);
     std::vector<std::string> ghu_headers = { "season", "day", "day_in_year", "species" };
     for (int h = 0; h < tomis_foobar; h++)
     {
         string str1 = IntakeSourceToString((TTypeOfMaxIntakeSource)h);
         ghu_headers.push_back(str1);
     }
     ghu_headers.push_back("count");
     WriteHeaders(m_GooseHabitatUseFile, ghu_headers);
     ClearGooseHabitatUseStats();
  
     m_GooseHabitatUseFieldObsFile = new ofstream("GooseHabitatUseFieldObsStats.txt", ios::out);
     std::vector<std::string> ghufo_headers = { "season", "day", "day_in_year", "species" };
     for (int h = 0; h < tomis_foobar; h++)
     {
         string str1 = IntakeSourceToString((TTypeOfMaxIntakeSource)h);
         ghufo_headers.push_back(str1);
     }
     ghufo_headers.push_back("count");
     WriteHeaders(m_GooseHabitatUseFieldObsFile, ghufo_headers);
     ClearGooseHabitatUseFieldObsStats();
  
     m_GooseLeaveReasonStatsFile = new ofstream("GooseLeaveReasonStats.txt", ios::out);
     std::vector<std::string> lr_headers = { "season", "day", "day_in_year", "species_type", "leave_reason", "n" };
     WriteHeaders(m_GooseLeaveReasonStatsFile, lr_headers);
  
     m_StateStatsFile = new ofstream("GooseStateStats.txt", ios::out);
     std::vector<std::string> ss_headers = { "season", "day", "n" };
     WriteHeaders(m_StateStatsFile, ss_headers);
  
     m_GooseEnergeticsDataFile = new ofstream("GooseEnergeticsData.txt", ios::out);
     std::vector<std::string> ed_headers;
     ed_headers = { "season", "day", "species", "foraging_time", "foraging_time_se",
                   "flight_distance", "flight_distance_se", "daily_energy_budget",
                   "daily_energy_budget_se", "daily_energy_balance",
                   "daily_energy_balance_se", "day_length" };
     WriteHeaders(m_GooseEnergeticsDataFile, ed_headers);
     m_GooseFieldForageDataFile = new ofstream("GooseFieldForageData.txt", ios::out);
     // We use two different versions dependent on whether we are testing of just running
     if (cfg_goose_runtime_reporting.value())
     {
         std::vector<std::string> fd_headers;
         fd_headers = {
             "season",
             "day",
             "geese",
             "pinkfoot",
             "pinkfoot_timed",
             "roost_dist_pinkfoot",
             "barnacle",
             "barnacle_timed",
             "roost_dist_barnacle",
             "greylag",
             "greylag_timed",
             "roost_dist_greylag",
             "polyref"
         };
         WriteHeaders(m_GooseFieldForageDataFile, fd_headers);
     }
     if (!cfg_goose_runtime_reporting.value())
     {
         std::vector<std::string> fd_headers;
         fd_headers = {"season", "day", "polyref",  "utm_x", "utm_y", "geese",
                       "geese_timed", "openness", "pinkfoot", "pinkfoot_timed",
                       "roost_dist_pinkfoot", "grass_pinkfoot", "barnacle",
                       "barnacle_timed", "roost_dist_barnacle", "grass_barnacle",
                       "greylag", "greylag_timed", "roost_dist_greylag", "grass_greylag",
                       "grain", "maize", "veg_type_chr", "veg_height", "digestability",
                       "veg_phase", "previous_crop", "last_sown_veg" };
         WriteHeaders(m_GooseFieldForageDataFile, fd_headers);
     }
     if (cfg_goose_ObservedOpennessQuery.value())
     {
         ObservedOpennessQuery();
     }
     if (cfg_goose_WriteConfig.value()) {
         WriteConfig();
     }
 #ifdef __GITVERSION
     if (l_map_print_git_version_info.value())
     {
         m_GooseGitVersionFile = new ofstream("almass-version.txt", ios::out);
         (*m_GooseGitVersionFile) << "hash=" << GIT_HASH << std::endl;
         (*m_GooseGitVersionFile) << "time=" << COMPILE_TIME << std::endl;
         (*m_GooseGitVersionFile) << "branch=" << GIT_BRANCH << std::endl;
     }
 #endif
 }

References cfg_AOROutput_used, cfg_goose_ObservedOpennessQuery, cfg_goose_runtime_reporting, cfg_goose_WriteConfig, cfg_ReallyBigOutput_used, ClearGooseHabitatUseFieldObsStats(), ClearGooseHabitatUseStats(), IntakeSourceToString(), l_map_print_git_version_info, m_AOR_Barnacles, m_AOR_Greylags, m_AOR_Pinkfeet, m_GooseEnergeticsDataFile, m_GooseFieldForageDataFile, m_GooseGitVersionFile, m_GooseHabitatUseFieldObsFile, m_GooseHabitatUseFile, m_GooseIndLocCountFile, m_GooseLeaveReasonStatsFile, m_GoosePopDataFile, m_GooseWeightStatsFile, m_GooseXYDumpFile, m_StateStatsFile, Population_Manager::m_TheLandscape, ObservedOpennessQuery(), Population_Manager::OpenTheReallyBigProbe(), Population_Manager::ReallyBigOutputPrb, tomis_foobar, CfgBool::value(), WriteConfig(), and WriteHeaders().

Referenced by Goose_Population_Manager().

◆ InPinkfootSeason()

bool Goose_Population_Manager::InPinkfootSeason ( )

inline

Are we in the pinkfoot hunting season?

418 { return m_PinkfootSeason; }

References m_PinkfootSeason.

Referenced by BirdsShot(), BirdsToShootAtPoly(), and GooseActiveForageLocation::GetHuntables().

◆ IntakeSourceToString()

std::string Goose_Population_Manager::IntakeSourceToString ( TTypeOfMaxIntakeSource a_intake_source )

protected

Translates tomis enum to string

 {
     switch (a_intake_source)
     {
     case tomis_grass:
         return "grass";
     case tomis_sowncrop:
         return "winter_cereal";
     case tomis_maize:
         return "maize";
     case tomis_grain:
         return "grain";
     default:
         return "tomis_foobar";
     }
 }

References tomis_grain, tomis_grass, tomis_maize, and tomis_sowncrop.

Referenced by Init().

◆ LeaveReasonToString()

std::string Goose_Population_Manager::LeaveReasonToString ( TTypeOfLeaveReason a_leave_reason )

protected

Translates tolr enum to string

 {
     switch (a_leave_reason)
     {
     case tolr_migration:
         return "migration";
     case tolr_bodycondition:
         return "body_condition";
     case tolr_leanweight:
         return "lean_weight";
     case tomis_grain:
         return "grain";
     default:
         return "tolr_foobar";
     }
 }

References tolr_bodycondition, tolr_leanweight, tolr_migration, and tomis_grain.

Referenced by GooseLeaveReasonStatOutput().

◆ NewForageLocation()

int Goose_Population_Manager::NewForageLocation	(	GooseSpeciesType	a_type,
		int	a_number,
		int	a_polyref
	)

Creates a new forage location and adds a goose or geese to the forage location. Returns an index to the forage location list.

Parameters

[in]	a_type	is type of goose species to forage here in this first forage group
[in]	a_number	is the number of geese in this first forarge group
[in]	a_polyref	is the polygon reference number that identifies the field for foraging

Adds the new forage location to the m_GooseForageLocations vector and adds the starting number of geese of the type specified. Calculates the distance to the closest roost for each species.

 {
     double grain = m_TheLandscape->SupplyBirdSeedForage( a_polyref );  // grain/m2
     double maize = m_TheLandscape->SupplyBirdMaizeForage( a_polyref );  // kJ/m2
     double grazing[gs_foobar];
     // NB GooseSpeciesType >> 1 becomes a GooseSpecies
     for (int g = 0; g < gs_foobar; g++)
     {
         grazing[g] = m_TheLandscape->GetActualGooseGrazingForage(a_polyref, (GooseSpecies) g);
     }
     GooseActiveForageLocation aFL(a_type, a_number, a_polyref, (int) m_TheLandscape->SupplyPolygonArea(a_polyref), grain, maize, grazing, this);
     aFL.ResetGrazing();
     // Calculate the distance to the closest roost for each species
     int x = m_TheLandscape->SupplyCentroidX(a_polyref);
     int y = m_TheLandscape->SupplyCentroidY(a_polyref);
     for (int i = 0; i < gs_foobar; i++) {
         double dist = GetDistToClosestRoost(x, y, i);
         aFL.SetDistToClosestRoost(i, dist);
     }
     m_GooseForageLocations.push_back(aFL);
     int ind = (int)m_GooseForageLocations.size() - 1;
     return ind;
 }

References Landscape::GetActualGooseGrazingForage(), GetDistToClosestRoost(), m_GooseForageLocations, Population_Manager::m_TheLandscape, GooseActiveForageLocation::ResetGrazing(), GooseActiveForageLocation::SetDistToClosestRoost(), Landscape::SupplyBirdMaizeForage(), Landscape::SupplyBirdSeedForage(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), and Landscape::SupplyPolygonArea().

Referenced by AddGeeseToForageLocationP(), and Goose_Base::st_ChooseForageLocation().

◆ ObservedOpennessQuery()

void Goose_Population_Manager::ObservedOpennessQuery ( )

protected

Writes a file with the openness scores on places where geese have been observed in the field.

Here locations of geese observed in the field are read in from a file and the openness score for those locations are written to a file.

Todo:: The string is padded by blank spaces - can this be fixed?

 {
     ofstream ofile("GooseObservedOpenness.txt", ios::out);
     ofile << "Polyref" << '\t' << "Openness" << '\t' << "ElementType" << '\t'<< "CentroidX" << '\t' << "CentroidY" << endl;
  
     ifstream ifile( "GooseObservations.txt" );
     if (!ifile.is_open())
     {
         m_TheLandscape->Warn( "Goose_Population_Manager::Goose_Population_Manager(Landscape* L) ", "GooseObservations.txt missing" );
         exit( 1 );
     }
  
     int no_entries;
     ifile >> no_entries;  // Read in the first line (number of lines)
  
     for (int i = 0; i < no_entries; i++)
     {
         int x;
         int y;
         string thetype;
         int centroidx;
         int centroidy;
         int thepolyref;
         int theopenness;
  
         ifile >> x >> y;  // Read in the first and second column as x and y
         thetype = m_TheLandscape->PolytypeToString(m_TheLandscape->SupplyElementType(x, y));  
         centroidx = m_TheLandscape->SupplyCentroidX(x, y);
         centroidy = m_TheLandscape->SupplyCentroidY(x, y);
         thepolyref = m_TheLandscape->SupplyPolyRef( x, y );
         theopenness = m_TheLandscape->SupplyOpenness( x, y );
  
         //Write out the stuff to a file.
         ofile << thepolyref << '\t' << theopenness << '\t' << thetype << '\t' << centroidx << '\t' << centroidy << endl;  
     }
     ifile.close();
     ofile.close();
 }

References Population_Manager::m_TheLandscape, Landscape::PolytypeToString(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Landscape::SupplyElementType(), Landscape::SupplyOpenness(), Landscape::SupplyPolyRef(), and Landscape::Warn().

Referenced by Init().

◆ RecordDailyEnergyBalance()

void Goose_Population_Manager::RecordDailyEnergyBalance	(	int	a_balance,
		GooseSpecies	a_species
	)

Record the daily energy balance.

 {
     m_DailyEnergyBalanceStats[a_species].add_variable(a_balance);
 }

References SimpleStatistics::add_variable(), and m_DailyEnergyBalanceStats.

Referenced by Goose_Base::StartDay().

◆ RecordDailyEnergyBudget()

void Goose_Population_Manager::RecordDailyEnergyBudget	(	int	a_deb,
		GooseSpecies	a_species
	)

Record the daily energy budget.

 {
     m_DailyEnergyBudgetStats[a_species].add_variable(a_deb);
 }

References SimpleStatistics::add_variable(), and m_DailyEnergyBudgetStats.

Referenced by Goose_Base::StartDay().

◆ RecordFlightDistance()

void Goose_Population_Manager::RecordFlightDistance	(	int	a_distance,
		GooseSpecies	a_species
	)

Record the flight distance.

 {
     m_FlightDistanceStats[a_species].add_variable(a_distance);
 }

References SimpleStatistics::add_variable(), and m_FlightDistanceStats.

Referenced by Goose_Base::StartDay().

◆ RecordForagingTime()

void Goose_Population_Manager::RecordForagingTime	(	int	a_time,
		GooseSpecies	a_species
	)

Record the time spent foraging.

 {
     m_ForagingTimeStats[a_species].add_variable(a_time);
 }

References SimpleStatistics::add_variable(), and m_ForagingTimeStats.

Referenced by Goose_Base::StartDay().

◆ RecordHabitatUse()

void Goose_Population_Manager::RecordHabitatUse	(	int	a_habitatype,
		GooseSpecies	a_species,
		int	a_count
	)

Record the habitat use.

 {
     m_HabitatUseStats[a_species * tomis_foobar + a_habitatype] += a_count;
 }

References m_HabitatUseStats, and tomis_foobar.

Referenced by DoLast().

◆ RecordHabitatUseFieldObs()

void Goose_Population_Manager::RecordHabitatUseFieldObs	(	int	a_habitatype,
		GooseSpecies	a_species,
		int	a_count
	)

Record the habitat use.

 {
     m_HabitatUseFieldObsStats[a_species * tomis_foobar + a_habitatype] += a_count;
 }

References m_HabitatUseFieldObsStats, and tomis_foobar.

Referenced by DoLast().

◆ RecordIndForageLoc()

void Goose_Population_Manager::RecordIndForageLoc	(	double	a_count,
		int	a_groupsize,
		GooseSpecies	a_species
	)

Record a forage location count.

 {
     for (int i=0; i<a_groupsize; i++) m_IndividualForageLocationData[a_species].add_variable(a_count);
 }

References m_IndividualForageLocationData.

Referenced by Goose_Base::StartDay().

◆ RecordLeaveReason()

void Goose_Population_Manager::RecordLeaveReason	(	TTypeOfLeaveReason	a_leavereason,
		GooseSpeciesType	a_speciestype
	)

Record the reason for leaving.

                                                                                                                  {
     m_LeaveReasonStats[a_speciestype][a_leavereason].add_variable(1);
 }

References SimpleStatistics::add_variable(), and m_LeaveReasonStats.

Referenced by Goose_Base::On_Migrate().

◆ RecordState()

void Goose_Population_Manager::RecordState ( )

Record the state.

                                            {
     m_StateStats.add_variable(1);
 }

References SimpleStatistics::add_variable(), and m_StateStats.

Referenced by Goose_Base::st_ChooseForageLocation().

◆ RecordWeight()

void Goose_Population_Manager::RecordWeight	(	double	a_weight,
		GooseSpecies	a_species
	)

Record the weight.

 {
     m_WeightStats[a_species].add_variable(a_weight);
 }

References SimpleStatistics::add_variable(), and m_WeightStats.

Referenced by Goose_Base::StartDay().

◆ RemoveGeeseFromForageLocation()

void Goose_Population_Manager::RemoveGeeseFromForageLocation	(	GooseSpeciesType	a_type,
		int	a_index,
		int	a_number
	)

Removes a goose or geese to the forage location - requires an index.

  {
      m_GooseForageLocations[a_index].RemoveGeese(a_type, a_number);
  }

References m_GooseForageLocations.

Referenced by Goose_Base::KillThis(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), Goose_Base::On_Bang(), Goose_Base::st_Forage(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), and Goose_Pinkfoot_Base::st_ToRoost().

◆ RemoveGrainKJ()

void Goose_Population_Manager::RemoveGrainKJ	(	double	a_kJ,
		int	a_index
	)

inline

Removes kJ eaten as grains from a forage area.

508 { m_GooseForageLocations[a_index].RemoveGrainKJ(a_kJ); }

References m_GooseForageLocations.

Referenced by RemoveMaxForageKj().

◆ RemoveMaizeKJ()

void Goose_Population_Manager::RemoveMaizeKJ	(	double	a_kJ,
		int	a_index
	)

inline

Removes KJ eaten as maize from a forage area.

                                                  {
         m_GooseForageLocations[a_index].RemoveMaizeKJ(a_kJ);
     }

References m_GooseForageLocations.

Referenced by RemoveMaxForageKj().

◆ RemoveMaxForageKj()

void Goose_Population_Manager::RemoveMaxForageKj	(	double	a_forage,
		TTypeOfMaxIntakeSource	a_maxintakesource,
		int	m_myForageIndex
	)

Removes the forage eaten from the field.

Parameters

[in]	a_forage	The forage to be removed in Kj
[in]	a_maxintakesource	The source of the max intake
[in]	m_myForageIndex	Temporary storage for a forage location index

                                                                                                                                {
     switch (a_maxintakesource) {
         case tomis_grain:
             RemoveGrainKJ( forage, m_myForageIndex );
             break;
         case tomis_maize:
             RemoveMaizeKJ( forage, m_myForageIndex );
             break;
         case tomis_grass:
             Graze( forage, m_myForageIndex );
             break;
         case tomis_foobar:
             m_TheLandscape->Warn( "Goose_Population_Manager::RemoveMaxForageKj", " - Somebody visited the foobar. Not allowed!" );
             exit( 0 );
         default:
             ;
     }
 }

References Graze(), Population_Manager::m_TheLandscape, RemoveGrainKJ(), RemoveMaizeKJ(), tomis_foobar, tomis_grain, tomis_grass, tomis_maize, and Landscape::Warn().

Referenced by Goose_Base::st_Forage().

◆ StateStatOutput()

void Goose_Population_Manager::StateStatOutput ( )

protected

Write simple stats for the states.

                   {
     int Day = m_TheLandscape->SupplyGlobalDate();
     (*m_StateStatsFile) << m_SeasonNumber << '\t' << Day << '\t' << m_StateStats.get_N() << endl;
 }

References SimpleStatistics::get_N(), Population_Manager::m_SeasonNumber, m_StateStats, Population_Manager::m_TheLandscape, and Landscape::SupplyGlobalDate().

Referenced by DoLast().

◆ TheAOROutputProbe()

void Goose_Population_Manager::TheAOROutputProbe ( )

protectedvirtual

The modified goose version of the standard output for creating AOR statistics.

Here the problem is that we can't use the standard outputs because of the special goose population structures. So we need some special adaptions to the probe. This is done by extending the AOR_Probe class and using this, one for each species We also need to do this only once per day, so since the main calling loops use days as triggers we need to return doing nothing if the time is wrong.

Reimplemented from Population_Manager.

                                                  {
     if (GetDayTime() == cfg_gooseAORtime.value())
     {
         m_AOR_Pinkfeet->DoProbe(gs_Pinkfoot);
         m_AOR_Barnacles->DoProbe(gs_Barnacle);
         m_AOR_Greylags->DoProbe(gs_Greylag);
     }
 }

References cfg_gooseAORtime, AOR_Probe_Goose::DoProbe(), GetDayTime(), m_AOR_Barnacles, m_AOR_Greylags, m_AOR_Pinkfeet, and CfgInt::value().

◆ TheRipleysOutputProbe()

virtual void Goose_Population_Manager::TheRipleysOutputProbe ( FILE * )

inlineprotectedvirtual

Does nothing, but we need it here because it automatically called by the Population_Manager if the NWordOutput is used.

Reimplemented from Population_Manager.

828 { ; };

◆ WriteConfig()

void Goose_Population_Manager::WriteConfig ( )

protected

Writes a file the values of the config variables used.

Write out the values of the configs used Handy when compiling the result documents

                                            {
     ofstream ofile( "GooseConfig.txt", ios::out);
     boost::io::ios_flags_saver  ifs( ofile );  // Only use fixed within the scope of WriteConfig
     ofile << fixed;
     ofile << "Variable" << '\t' << "Value" << endl;
     ofile << "GOOSE_PINKFOOTWEIGHT" << '\t' << cfg_goose_pf_baseweight.value() << endl;
     ofile << "GOOSE_BARNACLEWEIGHT" << '\t' << cfg_goose_bn_baseweight.value() << endl;
     ofile << "GOOSE_GREYLAGWEIGHT" << '\t' << cfg_goose_gl_baseweight.value() << endl;
     ofile << "GOOSE_FLIGHTCOST" << '\t' << cfg_goose_flightcost.value() << endl;
     ofile << "GOOSE_FORAGEDIST_PF" << '\t' << cfg_goose_pf_ForageDist.value() << endl;
     ofile << "GOOSE_FORAGEDIST_BN" << '\t' << cfg_goose_bn_ForageDist.value() << endl;
     ofile << "GOOSE_FORAGEDIST_GL" << '\t' << cfg_goose_gl_ForageDist.value() << endl;
     ofile << "GOOSE_BMRCONSTANTA" << '\t' << cfg_goose_BMRconstant1.value() << endl;
     ofile << "GOOSE_BMRCONSTANTB" << '\t' << cfg_goose_BMRconstant2.value() << endl;
     ofile << "GOOSE_THERMALCONSTANTA_PF" << '\t' << cfg_goose_pf_Thermalconstant.value() << endl;
     ofile << "GOOSE_THERMALCONSTANTA_BN" << '\t' << cfg_goose_bn_Thermalconstant.value() << endl;
     ofile << "GOOSE_THERMALCONSTANTA_GL" << '\t' << cfg_goose_gl_Thermalconstant.value() << endl;
     ofile << "GOOSE_THERMALCONSTANTB" << '\t' << cfg_goose_Thermalconstantb.value() << endl;
     ofile << "GOOSE_MAXAPPETITESCALER" << '\t' << cfg_goose_MaxAppetiteScaler.value() << endl;
     ofile << "GOOSE_MAXENERGYRESERVEPROPORTION" << '\t' << cfg_goose_MaxEnergyReserveProportion.value() << endl;
     ofile << "GOOSE_ENERGYCONTENTOFFAT" << '\t' << cfg_goose_EnergyContentOfFat.value() << endl;
     ofile << "GOOSE_METABOLICCONVCOSTS" << '\t' << cfg_goose_MetabolicConversionCosts.value() << endl;
     ofile << "GOOSE_MINFORAGEOPENNESS" << '\t' << cfg_goose_MinForageOpenness.value() << endl;
     ofile << "GOOSE_PF_SEXRATIO" << '\t' << cfg_goose_pf_sexratio.value() << endl;
     ofile << "GOOSE_BN_SEXRATIO" << '\t' << cfg_goose_bn_sexratio.value() << endl;
     ofile << "GOOSE_GL_SEXRATIO" << '\t' << cfg_goose_gl_sexratio.value() << endl;
     ofile << "GOOSE_PF_ARRIVEDATESTART" << '\t' << cfg_goose_pf_arrivedatestart.value() << endl;
     ofile << "GOOSE_PF_ARRIVEDATEEND" << '\t' << cfg_goose_pf_arrivedateend.value() << endl;
     ofile << "GOOSE_BN_ARRIVEDATESTART" << '\t' << cfg_goose_bn_arrivedatestart.value() << endl;
     ofile << "GOOSE_BN_ARRIVEDATEEND" << '\t' << cfg_goose_bn_arrivedateend.value() << endl;
     ofile << "GOOSE_GL_ARRIVEDATESTART" << '\t' << cfg_goose_gl_arrivedatestart.value() << endl;
     ofile << "GOOSE_GL_ARRIVEDATEEND" << '\t' << cfg_goose_gl_arrivedateend.value() << endl;
     ofile << "GOOSE_PF_LEAVINGDATESTART" << '\t' << cfg_goose_pf_leavingdatestart.value() << endl;
     ofile << "GOOSE_PF_LEAVINGDATEEND" << '\t' << cfg_goose_pf_leavingdateend.value() << endl;
     ofile << "GOOSE_BN_LEAVINGDATESTART" << '\t' << cfg_goose_bn_leavingdatestart.value() << endl;
     ofile << "GOOSE_BN_LEAVINGDATEEND" << '\t' << cfg_goose_bn_leavingdateend.value() << endl;
     ofile << "GOOSE_GL_LEAVINGDATESTART" << '\t' << cfg_goose_gl_leavingdatestart.value() << endl;
     ofile << "GOOSE_GL_LEAVINGDATEEND" << '\t' << cfg_goose_gl_leavingdateend.value() << endl;
     ofile << "GOOSE_GRAINDECAYRATEWINTER" << '\t' << cfg_goose_GrainDecayRateWinter.value() << endl;
     ofile << "GOOSE_GRAINDECAYRATESPRING" << '\t' << cfg_goose_GrainDecayRateSpring.value() << endl;
     ofile << "GOOSE_MAXSCAREDIST" << '\t' << cfg_goose_MaxScareDistance.value() << endl;
     ofile << "GOOSE_FOLLOWINGLIKELYHOOD_BN" << '\t' << cfg_goose_bn_followinglikelyhood.value() << endl;
     ofile << "GOOSE_FOLLOWINGLIKELYHOOD_PF" << '\t' << cfg_goose_pf_followinglikelyhood.value() << endl;
     ofile << "GOOSE_FOLLOWINGLIKELYHOOD_GL" << '\t' << cfg_goose_gl_followinglikelyhood.value() << endl;
     ofile << "GOOSE_ROOSTLEAVEDISTSD" << '\t' << cfg_goose_RoostLeaveDistSD.value() << endl;
     ofile << "GOOSE_ROOSTLEAVEDISTMEAN" << '\t' << cfg_goose_RoostLeaveDistMean.value() << endl;
     ofile << "GOOSE_INITIALENERGYRESERVEPROPORTION" << '\t' << cfg_goose_InitialEnergyReserveProportion.value() << endl;
     ofile << "GOOSE_ROOSTCHANGECHANCE" << '\t' << cfg_goose_roostchangechance.value() << endl;
     ofile << "GOOSE_LEAVEREASONSTATS" << '\t' << cfg_goose_LeaveReasonStats.value() << endl;
     ofile << "GOOSE_DIST_WEIGHTING_POWER" << '\t' << cfg_goose_dist_weight_power.value() << endl;
     ofile << "GOOSE_GRASS_TO_WINTER_CEREAL_SCALER" << '\t' << cfg_goose_grass_to_winter_cereal_scaler.value() << endl;
     ofile << "GOOSE_DAYTIMEBMRMULTIPLIER" << '\t' << cfg_goose_daytime_BMR_multiplier.value() << endl;
     ofile << "GOOSE_NIGHTTIMEBMRMULTIPLIER" << '\t' << cfg_goose_nighttime_BMR_multiplier.value() << endl;
     ofile << "GOOSE_SNOW_SCALER" << '\t' << cfg_goose_snow_scaler.value() << endl;
     ofile << "VEG_GROWTHSCALERMAX" << '\t' << cfg_PermanentVegGrowthMaxScaler.value() << endl;
     ofile << "VEG_GROWTHSCALERMIN" << '\t' << cfg_PermanentVegGrowthMinScaler.value() << endl;
     ofile.close();
 }

References cfg_goose_BMRconstant1, cfg_goose_BMRconstant2, cfg_goose_bn_arrivedateend, cfg_goose_bn_arrivedatestart, cfg_goose_bn_baseweight, cfg_goose_bn_followinglikelyhood, cfg_goose_bn_ForageDist, cfg_goose_bn_leavingdateend, cfg_goose_bn_leavingdatestart, cfg_goose_bn_sexratio, cfg_goose_bn_Thermalconstant, cfg_goose_daytime_BMR_multiplier, cfg_goose_dist_weight_power, cfg_goose_EnergyContentOfFat, cfg_goose_flightcost, cfg_goose_gl_arrivedateend, cfg_goose_gl_arrivedatestart, cfg_goose_gl_baseweight, cfg_goose_gl_followinglikelyhood, cfg_goose_gl_ForageDist, cfg_goose_gl_leavingdateend, cfg_goose_gl_leavingdatestart, cfg_goose_gl_sexratio, cfg_goose_gl_Thermalconstant, cfg_goose_GrainDecayRateSpring, cfg_goose_GrainDecayRateWinter, cfg_goose_grass_to_winter_cereal_scaler, cfg_goose_InitialEnergyReserveProportion, cfg_goose_LeaveReasonStats, cfg_goose_MaxAppetiteScaler, cfg_goose_MaxEnergyReserveProportion, cfg_goose_MaxScareDistance, cfg_goose_MetabolicConversionCosts, cfg_goose_MinForageOpenness, cfg_goose_nighttime_BMR_multiplier, cfg_goose_pf_arrivedateend, cfg_goose_pf_arrivedatestart, cfg_goose_pf_baseweight, cfg_goose_pf_followinglikelyhood, cfg_goose_pf_ForageDist, cfg_goose_pf_leavingdateend, cfg_goose_pf_leavingdatestart, cfg_goose_pf_sexratio, cfg_goose_pf_Thermalconstant, cfg_goose_roostchangechance, cfg_goose_RoostLeaveDistMean, cfg_goose_RoostLeaveDistSD, cfg_goose_snow_scaler, cfg_goose_Thermalconstantb, cfg_PermanentVegGrowthMaxScaler, cfg_PermanentVegGrowthMinScaler, CfgInt::value(), CfgFloat::value(), and CfgBool::value().

Referenced by Init().

◆ WriteHeaders()

void Goose_Population_Manager::WriteHeaders	(	ofstream *	a_file,
		std::vector< std::string >	a_headers
	)

protected

Handy function for writing headers.

 {
     for (int i = 0; i < a_headers.size(); ++i)
     {
         if (i <= a_headers.size() - 2)
         {
             (*a_file) << a_headers[i];
             (*a_file) << '\t';
         }
         else
         {
             (*a_file) << a_headers[i];
             (*a_file) << endl;
         }
     }
 }

Referenced by Init().

◆ XYDump()

void Goose_Population_Manager::XYDump ( )

protected

Outputs x y data.

                                       {
     // Families
     int total = int(GetLiveArraySize(gst_PinkfootFamilyGroup));
     int x, y, poly, index, gaflx, gafly, gaflpoly;
     //int w = m_TheLandscape->SupplySimAreaWidth();
     //int h = m_TheLandscape->SupplySimAreaHeight();
     
     for (int j = 0; j<total; j++)      
     {
         int group_size = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->GetGroupsize();
         for (int k = 0; k < group_size; k++)
         {
             x = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->Supply_m_Location_x();
             y = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->Supply_m_Location_y();
             poly = m_TheLandscape->SupplyPolyRef(x, y);
             index = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootFamilyGroup][j])->GetForageLocIndex();
             if (index != -1) {
                 GooseActiveForageLocation* gafl = GetForageLocation(index);
                 gaflpoly = gafl->GetPolygonref();
                 gaflx = m_TheLandscape->SupplyCentroidX(gaflpoly);
                 gafly = m_TheLandscape->SupplyCentroidY(gaflpoly);
             }
             else {
                 gaflpoly = -1;
                 gaflx = -1;
                 gafly = -1;
             }
             (*m_GooseXYDumpFile) << x << '\t' << y << '\t' << poly << '\t' <<
                 gaflx << '\t' << gafly << '\t' << gaflpoly <<  endl;
         }
     }
     // Non-breeders
     total = int(GetLiveArraySize(gst_PinkfootNonBreeder));
     
     for (int j = 0; j<total; j++)
     {
         x = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootNonBreeder][j])->Supply_m_Location_x();
         y = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootNonBreeder][j])->Supply_m_Location_y();
         poly = m_TheLandscape->SupplyPolyRef(x, y);
         index = dynamic_cast<Goose_Base*>(TheArray[gst_PinkfootNonBreeder][j])->GetForageLocIndex();
         if (index != -1) {
             GooseActiveForageLocation* gafl = GetForageLocation(index);
             gaflpoly = gafl->GetPolygonref();
             gaflx = m_TheLandscape->SupplyCentroidX(gaflpoly);
             gafly = m_TheLandscape->SupplyCentroidY(gaflpoly);
         }
         else {
             gaflpoly = -1;
             gaflx = -1;
             gafly = -1;
         }
         (*m_GooseXYDumpFile) << x << '\t' << y << '\t' << poly << '\t' <<
             gaflx << '\t' << gafly << '\t' << gaflpoly << endl;
     }
 }

References GetForageLocation(), GetForageLocIndex(), Population_Manager::GetLiveArraySize(), GooseActiveForageLocation::GetPolygonref(), gst_PinkfootFamilyGroup, gst_PinkfootNonBreeder, Population_Manager::m_TheLandscape, Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Landscape::SupplyPolyRef(), and Population_Manager::TheArray.

Referenced by DoLast().

Member Data Documentation

◆ m_AOR_Barnacles

AOR_Probe_Goose* Goose_Population_Manager::m_AOR_Barnacles

protected

AOR Probe for barnacles.

Referenced by Init(), TheAOROutputProbe(), and ~Goose_Population_Manager().

◆ m_AOR_Greylags

AOR_Probe_Goose* Goose_Population_Manager::m_AOR_Greylags

protected

AOR Probe for greylags.

Referenced by Init(), TheAOROutputProbe(), and ~Goose_Population_Manager().

◆ m_AOR_Pinkfeet

AOR_Probe_Goose* Goose_Population_Manager::m_AOR_Pinkfeet

protected

AOR Probe for pinkfeet.

Referenced by Init(), TheAOROutputProbe(), and ~Goose_Population_Manager().

◆ m_DailyEnergyBalanceStats

SimpleStatistics Goose_Population_Manager::m_DailyEnergyBalanceStats[gs_foobar]

protected

Statistics for the daily energy balance in the population.

Referenced by ClearGooseDailyEnergyBalanceStats(), GooseEnergyRecordOutput(), and RecordDailyEnergyBalance().

◆ m_DailyEnergyBudgetStats

SimpleStatistics Goose_Population_Manager::m_DailyEnergyBudgetStats[gs_foobar]

protected

Statistics for the daily energy budget in the population.

Referenced by ClearGooseDailyEnergyBudgetStats(), GooseEnergyRecordOutput(), and RecordDailyEnergyBudget().

◆ m_daylight

bool Goose_Population_Manager::m_daylight

protected

Flag for in daylight hours. Sunrise is always at m_daytime == 0.

Referenced by DoFirst(), and GetIsDaylight().

◆ m_daylightleft

int Goose_Population_Manager::m_daylightleft

protected

Number of daylight minutes left.

Referenced by DoFirst(), and GetDaylightLeft().

◆ m_daytime

int Goose_Population_Manager::m_daytime

protected

Holds the time of day. Note that sunrise is at m_daytime == 0.

Referenced by DoFirst(), DoLast(), GetDayTime(), and Goose_Population_Manager().

◆ m_FlightDistanceStats

SimpleStatistics Goose_Population_Manager::m_FlightDistanceStats[gs_foobar]

protected

Statistics for the flight distances in the population.

Referenced by ClearGooseFlightDistanceStats(), GooseEnergyRecordOutput(), and RecordFlightDistance().

◆ m_ForageRateVSGooseDensity

PettiforFeedingTimeCurveClass* Goose_Population_Manager::m_ForageRateVSGooseDensity

protected

Speed optimisation to hold all potential competition reductions in the range 0 - 1 goose/m2.

Speed optimisation to hold all potential feeding time increases as a function of flock size

Referenced by GetForageRateDensity(), Goose_Population_Manager(), and ~Goose_Population_Manager().

◆ m_ForagingTimeStats

SimpleStatistics Goose_Population_Manager::m_ForagingTimeStats[gs_foobar]

protected

Statistics for the time spent foraging for the population.

Referenced by ClearGooseForagingTimeStats(), GooseEnergyRecordOutput(), and RecordForagingTime().

◆ m_GooseEnergeticsDataFile

ofstream* Goose_Population_Manager::m_GooseEnergeticsDataFile

protected

Pointer to an output file for goose energetics data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseFieldForageDataFile

ofstream* Goose_Population_Manager::m_GooseFieldForageDataFile

protected

Pointer to an output file for goose field forage data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseForageLocations

std::vector<GooseActiveForageLocation> Goose_Population_Manager::m_GooseForageLocations

Is a list of active goose forage locations where we have geese.

Referenced by AddGeeseToForageLocation(), AddGeeseToForageLocationP(), BirdsShot(), BirdsToShootAtPoly(), DoFirst(), DoLast(), ForageLocationInUse(), GetBirdsAtForageLoc(), GetForageGooseDensity(), GetForageGrazing(), GetForageLocation(), GetForageLocIndex(), GetGrainDensity(), GetMaizeDensity(), GetNumberOfForageLocs(), Graze(), NewForageLocation(), RemoveGeeseFromForageLocation(), RemoveGrainKJ(), RemoveMaizeKJ(), and Goose_Base::st_Forage().

◆ m_GooseGitVersionFile

ofstream* Goose_Population_Manager::m_GooseGitVersionFile

protected

Pointer to an output file for almass version.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseHabitatUseFieldObsFile

ofstream* Goose_Population_Manager::m_GooseHabitatUseFieldObsFile

protected

Pointer to an output file for goose habitat use data, field observation mimic version.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseHabitatUseFile

ofstream* Goose_Population_Manager::m_GooseHabitatUseFile

protected

Pointer to an output file for goose habitat use data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseIndLocCountFile

ofstream* Goose_Population_Manager::m_GooseIndLocCountFile

protected

Pointer to an output file for goose individual forage location count data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseLeaveReasonStatsFile

ofstream* Goose_Population_Manager::m_GooseLeaveReasonStatsFile

protected

Pointer to an output file for goose leave reason stats data.

Referenced by Init().

◆ m_GoosePopDataFile

ofstream* Goose_Population_Manager::m_GoosePopDataFile

protected

Pointer to an output file for goose population data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseWeightStatsFile

ofstream* Goose_Population_Manager::m_GooseWeightStatsFile

protected

Pointer to an output file for goose weight stats data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GooseXYDumpFile

ofstream* Goose_Population_Manager::m_GooseXYDumpFile

protected

Pointer to an output file for goose x y data.

Referenced by Init(), and ~Goose_Population_Manager().

◆ m_GreylagSeason

bool Goose_Population_Manager::m_GreylagSeason

protected

Flag to indicate if we are in the greylag hunting season.

Referenced by BirdsShot(), DoFirst(), Goose_Population_Manager(), and InGreylagSeason().

◆ m_HabitatUseFieldObsStats

int Goose_Population_Manager::m_HabitatUseFieldObsStats[gs_foobar *tomis_foobar]

protected

Data for the habitat use, field observation mimic version.

Referenced by ClearGooseHabitatUseFieldObsStats(), GooseHabitatUseFieldObsOutput(), and RecordHabitatUseFieldObs().

◆ m_HabitatUseStats

int Goose_Population_Manager::m_HabitatUseStats[gs_foobar *tomis_foobar]

protected

Data for the habitat use.

Referenced by ClearGooseHabitatUseStats(), GooseHabitatUseOutput(), and RecordHabitatUse().

◆ m_IndividualForageLocationData

SimpleStatistics Goose_Population_Manager::m_IndividualForageLocationData[gs_foobar]

protected

Statistics for the number of forage locations visited per goose of the population.

Referenced by ClearIndLocCountStats(), GooseIndLocCountOutput(), and RecordIndForageLoc().

◆ m_IntakeRateVSGrainDensity_PF

HollingsDiscCurveClass* Goose_Population_Manager::m_IntakeRateVSGrainDensity_PF

protected

Speed optimisation to hold all potential forage rates in the range 0-X grain density per m2.

Referenced by GetFeedingRate(), Goose_Population_Manager(), and ~Goose_Population_Manager().

◆ m_IntakeRateVSMaizeDensity_BN

HollingsDiscCurveClass* Goose_Population_Manager::m_IntakeRateVSMaizeDensity_BN

protected

Speed optimisation to hold all potential forage rates in the range 0-X maize density per m2.

Todo:: fix

Referenced by GetMaizeFeedingRate(), Goose_Population_Manager(), and ~Goose_Population_Manager().

◆ m_LeaveReasonStats

SimpleStatistics Goose_Population_Manager::m_LeaveReasonStats[gst_foobar][tolr_foobar]

protected

Statistics for reasons for leaving the simulation.

Referenced by ClearGooseLeaveReasonStats(), GooseLeaveReasonStatOutput(), and RecordLeaveReason().

◆ m_migrationnumbers

int Goose_Population_Manager::m_migrationnumbers[3][2]

protected

Storage for goose numbers. Used when birds are immigrating.

Referenced by DoImmigration(), and GetImmigrationNumbers().

◆ m_PinkfootSeason

bool Goose_Population_Manager::m_PinkfootSeason

protected

Flag to indicate if we are in the pinkfoot hunting season?

Referenced by BirdsShot(), DoFirst(), Goose_Population_Manager(), and InPinkfootSeason().

◆ m_roosts

std::vector<roostlist> Goose_Population_Manager::m_roosts

protected

The list of roosts

Referenced by DoImmigration(), FindClosestRoost(), GetDistToClosestRoost(), and Goose_Population_Manager().

◆ m_StateStats

SimpleStatistics Goose_Population_Manager::m_StateStats

protected

Debugging code. Statistics for the number of times a state method is called.

Referenced by ClearStateStats(), RecordState(), and StateStatOutput().

◆ m_StateStatsFile

ofstream* Goose_Population_Manager::m_StateStatsFile

protected

Pointer to an output file for state stats data.

Referenced by Init().

◆ m_thermalcosts

double Goose_Population_Manager::m_thermalcosts[3]

protected

Temporary storage for daily goose energetic thermal costs constant for each species.

Referenced by DoFirst(), GetThermalCosts(), and Goose_Population_Manager().

◆ m_variate_generator

Variate_gen* Goose_Population_Manager::m_variate_generator

Function to be able to draw randomly from predefined distributions.

Referenced by Goose_Population_Manager(), Goose_Base::StartDay(), and ~Goose_Population_Manager().

◆ m_WeightStats

SimpleStatistics Goose_Population_Manager::m_WeightStats[gs_foobar]

protected

Statistics for the weights of the population.

Referenced by ClearGooseWeightStats(), GooseWeightStatOutput(), and RecordWeight().

◆ m_youngdist

std::vector<int> Goose_Population_Manager::m_youngdist

protected

The observed distribution of young for pink feet.

Referenced by DoImmigration(), and Goose_Population_Manager().

The documentation for this class was generated from the following files:

/builds/a1mass/almass_stable_oddox/GooseManagement/Goose_Population_Manager.h
/builds/a1mass/almass_stable_oddox/GooseManagement/Goose_Population_Manager.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Goose_Population_Manager()

◆ ~Goose_Population_Manager()

Member Function Documentation

◆ AddGeeseToForageLocation()

◆ AddGeeseToForageLocationP()

◆ BangAtPoly()

◆ BirdsShot()

◆ BirdsToShootAtPoly()

◆ ClearGooseDailyEnergyBalanceStats()

◆ ClearGooseDailyEnergyBudgetStats()

◆ ClearGooseFlightDistanceStats()

◆ ClearGooseForagingTimeStats()

◆ ClearGooseHabitatUseFieldObsStats()

◆ ClearGooseHabitatUseStats()

◆ ClearGooseLeaveReasonStats()

◆ ClearGooseWeightStats()

◆ ClearIndLocCountStats()

◆ ClearStateStats()

◆ CloseTheReallyBigOutputProbe()

◆ CloseTheRipleysOutputProbe()

◆ CreateObjects()

◆ DoAfter()

◆ DoBefore()

◆ DoEmigration()

◆ DoFirst()

◆ DoImmigration()

◆ DoLast()

◆ FindClosestRoost()

◆ ForageLocationInUse()

◆ GetBirdsAtForageLoc()

◆ GetDaylightLeft()

◆ GetDayTime()

◆ GetDistToClosestRoost()

◆ GetFeedingRate()

◆ GetForageGooseDensity()

◆ GetForageGrazing()

◆ GetForageLocation()

◆ GetForageLocIndex()

◆ GetForageRateDensity()

◆ GetGrainDensity()

◆ GetImmigrationNumbers()

◆ GetIsDaylight()

◆ GetLeader()

◆ GetMaizeDensity()

◆ GetMaizeFeedingRate()

◆ GetNumberOfForageLocs()

◆ GetThermalCosts()

◆ GooseEnergyRecordOutput()

◆ GooseFieldForageInfoOutput()

◆ GooseHabitatUseFieldObsOutput()

◆ GooseHabitatUseOutput()

◆ GooseIndLocCountOutput()

◆ GooseLeaveReasonStatOutput()

◆ GoosePopulationDescriptionOutput()

◆ GooseToString()

◆ GooseTypeToString()

◆ GooseWeightStatOutput()

◆ Graze()

◆ InGreylagSeason()

◆ InHuntingSeason()

◆ Init()

◆ InPinkfootSeason()

◆ IntakeSourceToString()

◆ LeaveReasonToString()

◆ NewForageLocation()

◆ ObservedOpennessQuery()

◆ RecordDailyEnergyBalance()

◆ RecordDailyEnergyBudget()

◆ RecordFlightDistance()

◆ RecordForagingTime()

◆ RecordHabitatUse()

◆ RecordHabitatUseFieldObs()

◆ RecordIndForageLoc()

◆ RecordLeaveReason()